public static void DetectRegistrationsLoop(TokenStore store)
{
var vertices = store.Providers.Select(x => new ProviderVertex {
Provider = x.Value, Token = x.Key
})
.ToDictionary(x => x.Token);
var rootVertex = new ProviderVertex {
Token = store.RootToken
};
vertices.Add(store.RootToken, rootVertex);
foreach (var vertex in vertices.Values.Where(x => x.Token != store.RootToken))
{
foreach (var dependency in vertex.Provider.Dependencies)
{
vertices[dependency.Token].Dependencies.Add(vertex);
}
}
foreach (var loop in new TarjanLoopDetection <ProviderVertex>().DetectLoop(vertices.Values.ToArray()).Where(x => x.Count > 1))
{
var types = string.Join(",", loop.Select(x => x.Token));
var tuples = loop.Select(x => new Tuple <IToken, IDiagInfo>(x.Token, x.Provider.DiagInfo)).ToList();
throw new DetailedRegistrationException("Following types declare a dependency loop" + types, tuples);
}
}
public async Task SendAsync_WithValidCachedToken_Returns200()
{
var packageSource = new PackageSource("http://package.source.net");
var tokenStore = new TokenStore();
tokenStore.AddToken(packageSource.SourceUri, "TEST-TOKEN");
Func <string, string, string> tokenFactory = (endpoint, realm) =>
{
throw new InvalidOperationException("Should NOT mint new token.");
};
var handler = new StsAuthenticationHandler(packageSource, tokenStore, tokenFactory)
{
InnerHandler = new LambdaMessageHandler(
request =>
{
var decodedToken = GetStsTokenFromRequest(request, decode: false);
Assert.NotNull(decodedToken);
Assert.Equal("TEST-TOKEN", decodedToken);
return(new HttpResponseMessage(HttpStatusCode.OK));
})
};
var response = await SendAsync(handler);
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
private void SetToken(dynamic user)
{
var token = Guid.NewGuid().ToString();
_users.SetToken(token, user);
TokenStore.SetClientAccess(token);
}
public void should_indicate_token_exists()
{
var sessionState = Substitute.For<ISession>();
var tokenStore = new TokenStore<Token>(sessionState);
sessionState[TokenStore<Token>.SessionKey].Returns(new Token());
tokenStore.Exists().ShouldBeTrue();
}
public override Task TokenEndpointResponse(OAuthTokenEndpointResponseContext context)
{
//記錄token
var datafile = "c:\\temp\\accesstoken.txt";
List <claimitem> citem = new List <claimitem>();
foreach (var item in context.Identity.Claims)
{
var c = new claimitem()
{
issuer = item.Issuer,
value = item.Value,
oris = item.OriginalIssuer,
claimtype = item.Type,
};
citem.Add(c);
}
var uid = citem.Find(x => x.claimtype == "UserID").value;
var userdata = citem.Find(x => x.claimtype == "user").value;
TokenStore data = new TokenStore()
{
token = context.AccessToken, UserId = uid, user = userdata
};
Directory.CreateDirectory("c:\\temp\\");
File.WriteAllText(datafile, JsonConvert.SerializeObject(data));
return(base.TokenEndpointResponse(context));
}
private OAuthToken GenerateAccessToken(UserSignature user, TokenStore store)
{
try
{
Dictionary <string, string> requestParams = new Dictionary <string, string>();
requestParams.Add(Constants.CLIENT_ID, ClientID);
requestParams.Add(Constants.CLIENT_SECRET, ClientSecret);
requestParams.Add(Constants.REDIRECT_URL, RedirectURL);
requestParams.Add(Constants.GRANT_TYPE, Constants.GRANT_TYPE_AUTH_CODE);
requestParams.Add(Constants.CODE, GrantToken);
string response = GetResponseFromServer(requestParams);
store.SaveToken(user, ParseResponse(response));
}
catch (System.Exception ex) when(!(ex is SDKException))
{
throw new SDKException(Constants.SAVE_TOKEN_ERROR, ex);
}
return(this);
}
public void should_clear_token()
{
var sessionState = Substitute.For<ISession>();
var tokenStore = new TokenStore<Token>(sessionState);
tokenStore.Clear();
sessionState.Received()[TokenStore<Token>.SessionKey] = (Token)null;
}
public InnerRegistration1(TokenStore store, IDependency <T1> dependency, IFilterToken groupToken, int priority)
{
this.store = store;
this.dependency = dependency;
this.groupToken = groupToken;
this.priority = priority;
}
public void Initialize()
{
Utility.AssertNotNull(user, errorMessage, Constants.USERSIGNATURE_ERROR_MESSAGE);
Utility.AssertNotNull(environment, errorMessage, Constants.ENVIRONMENT_ERROR_MESSAGE);
Utility.AssertNotNull(token, errorMessage, Constants.TOKEN_ERROR_MESSAGE);
if (store == null)
{
store = new FileStore(Path.GetDirectoryName(Assembly.GetCallingAssembly().Location) + Path.DirectorySeparatorChar + Constants.TOKEN_FILE);
}
if (sdkConfig == null)
{
sdkConfig = new SDKConfig.Builder().Build();
}
if (resourcePath == null)
{
resourcePath = Path.GetDirectoryName(Assembly.GetCallingAssembly().Location);
}
if (logger == null)
{
logger = new Logger.Logger.Builder().Level(API.Logger.Logger.Levels.INFO).FilePath(Path.GetDirectoryName(Assembly.GetCallingAssembly().Location) + Path.DirectorySeparatorChar + Constants.LOG_FILE_NAME).Build();
}
Initializer.Initialize(this.user, this.environment, this.token, this.store, this.sdkConfig, this.resourcePath, this.logger, this.requestProxy);
}
public async Task SendAsync_WithNotSupportedProtocol_PassesThru()
{
var packageSource = new PackageSource("http://package.source.net");
var tokenStore = new TokenStore();
Func <string, string, string> tokenFactory = (endpoint, realm) =>
{
throw new InvalidOperationException("Should NOT mint new token.");
};
var handler = new StsAuthenticationHandler(packageSource, tokenStore, tokenFactory)
{
InnerHandler = new LambdaMessageHandler(
request =>
{
var authResponse = new HttpResponseMessage(HttpStatusCode.Unauthorized);
authResponse.Headers.Add("WWW-Authenticate", "Basic realm=\"TEST-REALM\"");
return(new HttpResponseMessage(HttpStatusCode.Unauthorized));
})
};
var response = await SendAsync(handler);
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
}
public async Task SendAsync_RetryWithClonedRequest()
{
var packageSource = new PackageSource("http://package.source.net");
var tokenStore = new TokenStore();
tokenStore.AddToken(packageSource.SourceUri, "TEST-TOKEN");
Func <string, string, string> tokenFactory = (endpoint, realm) =>
{
throw new InvalidOperationException("Should NOT mint new token.");
};
var requests = 0;
var handler = new StsAuthenticationHandler(packageSource, tokenStore, tokenFactory)
{
InnerHandler = new LambdaMessageHandler(
request =>
{
Assert.Null(request.Headers.Authorization);
request.Headers.Authorization = new AuthenticationHeaderValue("Basic", "TEST");
requests++;
tokenStore.AddToken(packageSource.SourceUri, "TEST-TOKEN"); // update version for retry
return(new HttpResponseMessage(HttpStatusCode.Unauthorized));
})
};
var response = await SendAsync(handler);
Assert.True(requests > 1, "No retries");
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
}
private OAuthToken RefreshAccessToken(UserSignature user, TokenStore store)
{
try
{
Dictionary <string, string> requestParams = new Dictionary <string, string>();
requestParams.Add(Constants.CLIENT_ID, ClientId);
requestParams.Add(Constants.CLIENT_SECRET, ClientSecret);
requestParams.Add(Constants.GRANT_TYPE, Constants.REFRESH_TOKEN);
requestParams.Add(Constants.REFRESH_TOKEN, RefreshToken);
string response = GetResponseFromServer(requestParams);
ParseResponse(response);
if (string.IsNullOrEmpty(this.id) || string.IsNullOrWhiteSpace(this.id))
{
GenerateId();
}
store.SaveToken(user, this);
}
catch (System.Exception ex) when(!(ex is SDKException))
{
throw new SDKException(Constants.SAVE_TOKEN_ERROR, ex);
}
return(this);
}
internal BatchingTokenRepository(TokenStore <RECORD> store, RecordAccess_Loader <RECORD, Void> loader)
{
this._store = store;
this._loader = loader;
this._highId = ( int )store.HighId;
this._highestCreatedId = _highId - 1;
}
public static Tree CreateTree(this TokenStore store)
{
ProviderLoopDetectionService.DetectRegistrationsLoop(store);
var tree = new Tree();
tree.Root = new RootNode(tree, store.RootToken);
var context = store.CreateTreeContext(tree);
context.CreateNodes();
var nodeDependencies = context.GroupNodes();
context.CalculateNodeWeights(nodeDependencies);
context.BuildNodesTree(nodeDependencies);
ReorderNodesForFilters(context);
context.Filters.ForEach(context.AssignFilter);
int i = 0;
tree.FilterIndex = context.Filters.ToDictionary(x => x, x => i++);
FiltersLoopDetectionService.DetectFilterDependenciesLoop(tree);
// actual resolution starts here
tree.RootContext = new ResolutionContext <Root>(Root.Instance, tree.Root, null, store);
return(tree);
}
public InnerHighLevelRegistration(TokenStore store, IFilterToken groupToken, int priority, params IDependency[] dependencies)
{
this.store = store;
this.groupToken = groupToken;
this.priority = priority;
this.dependencies = dependencies;
}
public async Task SendAsync_WithValidAcquiredToken_RetriesRequest()
{
var packageSource = new PackageSource("http://package.source.net");
var tokenStore = new TokenStore();
Func <string, string, string> tokenFactory = (endpoint, realm) => $"{realm}@{endpoint}";
var handler = new StsAuthenticationHandler(packageSource, tokenStore, tokenFactory)
{
InnerHandler = new LambdaMessageHandler(
request =>
{
var decodedToken = GetStsTokenFromRequest(request);
if (decodedToken == null)
{
var authResponse = new HttpResponseMessage(HttpStatusCode.Unauthorized);
authResponse.Headers.Add(StsAuthenticationHandler.STSEndPointHeader, "http://TEST_ENDPOINT");
authResponse.Headers.Add(StsAuthenticationHandler.STSRealmHeader, "TEST-REALM");
return(authResponse);
}
Assert.Equal("TEST-REALM@http://TEST_ENDPOINT", decodedToken);
return(new HttpResponseMessage(HttpStatusCode.OK));
})
};
var response = await SendAsync(handler);
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
private void TokenStoreTest(string url, string token)
{
try
{
Uri uri = new Uri(url, UriKind.Absolute);
ITokenStore tokenStore = new TokenStore("token-test");
Token writeToken = new Token(token);
Token readToken = null;
tokenStore.WriteToken(uri, writeToken);
if (tokenStore.ReadToken(uri, out readToken))
{
Assert.AreEqual(writeToken.Value, readToken.Value, "Tokens did not match between written and read");
}
else
{
Assert.Fail("Failed to read credentials");
}
tokenStore.DeleteToken(uri);
Assert.IsFalse(tokenStore.ReadToken(uri, out readToken), "Deleted token was read back");
}
catch (Exception exception)
{
Assert.Fail(exception.Message);
}
}
public void should_indicate_token_doesent_exist()
{
var sessionState = Substitute.For<ISession>();
var tokenStore = new TokenStore<Token>(sessionState);
sessionState[TokenStore<Token>.SessionKey].Returns((Token)null);
tokenStore.Exists().ShouldBeFalse();
}
public DefaultPayloadBuilder(TokenStore <string, object> token_store, ItemWithProperty item_with_property,
PropertyExpressionTokenFactory token_factory)
{
this.token_store = token_store;
this.item_with_property = item_with_property;
this.token_factory = token_factory;
}
public void should_set_token()
{
var sessionState = Substitute.For<ISession>();
var tokenStore = new TokenStore<Token>(sessionState);
var token = new Token();
tokenStore.Set(token);
sessionState.Received()[TokenStore<Token>.SessionKey] = token;
}
public ViessmannConfigConnectionProvider(TokenStore <T> tokenStore, IOptions <ViessmannConfig> config, ViessmannHttpClient <T> client)
: base(new ViessmannAuth <T>(tokenStore))
{
ClientId = config.Value.ClientId;
RedirectUri = config.Value.RedirectUri;
Client = client.Client;
}
public async void TestTokenStoreSave()
{
var db = GetMockDbContext();
var tokenStore = new TokenStore <TokenStoreTest>(db, GetOptions());
await tokenStore.UpdateToken("accessToken", new DateTime(2019, 1, 1, 12, 0, 0), "refreshToken");
Mock.Get(db).Verify(d => d.SaveChangesAsync(default), Times.Once);
public async Task AddToken(TokenStore tokenStoreEntity)
{
if (!_dbContext.Set <TokenStore>().Any(t => t.Token == tokenStoreEntity.Token))
{
_dbContext.TokenStore.Add(tokenStoreEntity);
}
await Commit();
}
public async Task <ProtectedTaskflow <TransferTask> > CommitTransfer(TokenStore source, TokenStore destination, decimal transferAmount, string reference = null)
{
Trace($"Transfer {transferAmount} from {source} to {destination}");
// Prepare
var task = new TransferTask
{
SourceID = source.AccountID,
DestinationID = destination.AccountID,
SourceManagerPublicKey = source.Manager.PublicKey.ToString(),
NetworkFee = DefaultOperationFee,
TransferAmount = transferAmount,
Reference = reference,
};
var flow = new ProtectedTaskflow <TransferTask>(task);
try
{
Trace("Prepare Transfer");
flow.Task = task = await Connection.PrepareTransfer(task);
}
catch
{
flow.Update(TaskProgress.Failed);
}
if (flow.IsFailed)
{
return(flow);
}
// External Signing
if (await Sign(task, source.Manager))
{
try
{
// Submit
Trace("Execute CreateContract");
flow.Task = await Connection.Transfer(task);
flow.SetPending(this);
}
catch (Exception e)
{
Trace(e);
flow.Update(TaskProgress.Failed);
}
}
else
{
Trace("Sign cancelled");
flow.Update(TaskProgress.Cancelled);
}
return(flow);
}
public void should_get_existing_token()
{
var sessionState = Substitute.For<ISession>();
var tokenStore = new TokenStore<Token>(sessionState);
var token = new Token();
sessionState[TokenStore<Token>.SessionKey].Returns(token);
var result = tokenStore.Get();
token.ShouldEqual(result);
}
public NodeFilterInfo(TokenStore store, IToken token)
{
var and = new AndGroup();
var inversionInfo = store?.ItemInversions.SafeGet(token);
Group = and;
ItemFilter = inversionInfo == null ? (IFilter)and : new Inverter(and, new FilterInfo(0, inversionInfo));
}
public DefaultUrlBuilder(Type command_to_run, PayloadBuilderFactory payload_builder_factory, TokenStore <string, object> token_store, UrlFormattingVisitor url_formatting_visitor)
{
this.command_to_run = command_to_run;
this.url_formatting_visitor = url_formatting_visitor;
this.token_store = token_store;
this.payload_builder_factory = payload_builder_factory;
token_store.register(new KeyValuePair <string, object>("Foo", command_to_run));
}
private static IList <NamedToken> AllTokensFrom <T1>(TokenStore <T1> store)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: try (org.neo4j.kernel.impl.store.TokenStore<?> tokens = store)
using (TokenStore <object> tokens = store)
{
return(tokens.Tokens);
}
}
public TestingContext()
{
store = new TokenStore();
Inversion = new Inversion(store);
var inner = new InnerRegistration(store, null, DefaultPriority);
var innerHighLevel = new InnerHighLevelRegistration(store, null, DefaultPriority);
reg = new Registration(store, inner, innerHighLevel);
}
public TokenManager(ILogger <TokenManager> logger, IHttpClientFactory clientFactory, Store store)
{
_logger = logger;
_clientFactory = clientFactory;
_store = store;
logger.LogDebug("Getting Existing Token From Store");
_currentToken = _store.Get <TokenStore>();
}
public ViessmannConfigConnectionProvider(TokenStore <T> tokenStore, IOptions <ViessmannConfig> config, ViessmannHttpClient <T> client, ViessmannAuthHttpClient authClient)
: base(new ViessmannAuth <T>(tokenStore, config.Value.Username, config.Value.Password))
{
PlattformApiClientId = config.Value.PlattformApiClientId;
PlattformApiClientSecret = config.Value.PlattformApiClientSecret;
Client = client.Client;
AuthClient = authClient.AuthClient;
}
public TeamTimeWarp_VsPackagePackage()
{
_restServiceUriFactory = new RestServiceUriFactory();
_tokenStore = new TokenStore();
_tokenPersister = new TokenPersister();
_authenticationService = new AuthenticationService(_tokenStore, _restServiceUriFactory, _tokenPersister, new SynchronizationContext());
_userStateService = new UserStateService(_tokenStore, _restServiceUriFactory,
new AgentTypeProvider(TimeWarpAgent.VisualStudio));
}
public GroupProvider(IEnumerable <IDependency> dependencies,
IFilterGroup group,
TokenStore store,
IDiagInfo diagInfo)
{
Dependencies = dependencies;
DiagInfo = diagInfo;
this.group = group;
this.store = store;
}
static void Main(string[] args)
{
Trace.Listeners.Add(new ConsoleTraceListener());
// Re-create UserDetails and TokenStore minimums
UserDetails userDetails = new UserDetails
{
DeviceId = Guid.Parse(""),
DeviceIdExpiry = DateTime.Parse(""),
Email = "",
UserId = "",
};
TokenStore tokenStore = new TokenStore
{
access_token = "",
CreatedDate = DateTime.Parse("")
};
// Set the pin
string myPin = "1234";
// Connect to the JLR API with token data
JlrSharpConnection jlrSharp = new JlrSharpConnection(userDetails, tokenStore);
// Disable automatic refreshing of the tokens
jlrSharp.AutoRefreshTokens = false;
Trace.TraceInformation("Grabbing default vehicle");
// Grab the generic vehicle
Vehicle defaultVehicle = jlrSharp.GetPrimaryVehicle();
Console.WriteLine($"Mileage: {defaultVehicle.GetMileage()}");
Console.WriteLine($"Distance until empty: {defaultVehicle.GetDistanceUntilEmpty()}");
defaultVehicle.Unlock(myPin);
// wait before issuing these back to back
defaultVehicle.Lock(myPin);
// Determine the vehicle type
if (defaultVehicle is GasVehicle gasVehicle)
{
Console.WriteLine($"The fuel level is at {gasVehicle.GetFuelLevelPercentage()}%");
gasVehicle.StartEngine(myPin);
// wait before issuing these back to back
gasVehicle.StopEngine(myPin);
}
else if (defaultVehicle is ElectricVehicle electricVehicle)
{
Console.WriteLine($"Vehicle is charging: {electricVehicle.IsCharging()}");
Console.WriteLine($"Time until charged: {electricVehicle.GetTimeUntilCharged()}");
Console.WriteLine($"Charge level: {electricVehicle.GetChargeLevel()}");
electricVehicle.StopCharging(myPin);
}
}
public void Authenticate(APIHTTPConnector urlConnection)
{
lock (this)
{
try
{
Initializer initializer = Initializer.GetInitializer();
TokenStore store = initializer.Store;
UserSignature user = initializer.User;
OAuthToken oauthToken = null;
if (this.accessToken == null)
{
if (this.id != null)
{
oauthToken = (OAuthToken)store.GetTokenById(this.id, this);
}
else
{
oauthToken = (OAuthToken)store.GetToken(user, this);
}
}
else
{
oauthToken = this;
}
string token = "";
if (oauthToken == null)//first time
{
token = this.refreshToken != null?this.RefreshAccessToken(user, store).AccessToken : this.GenerateAccessToken(user, store).AccessToken;
}
else if (oauthToken.ExpiresIn != null && GetExpiryLapseInMillis(oauthToken.ExpiresIn) < 5L)//access token will expire in next 5 seconds or less
{
SDKLogger.LogInfo(Constants.REFRESH_TOKEN_MESSAGE);
token = oauthToken.RefreshAccessToken(user, store).AccessToken;
}
else
{
token = oauthToken.AccessToken;
}
urlConnection.AddHeader(Constants.AUTHORIZATION, Constants.OAUTH_HEADER_PREFIX + token);
}
catch (System.Exception ex) when(!(ex is SDKException))
{
throw new SDKException(ex);
}
}
}
/// <summary>
/// Ctor
/// </summary>
public IdentityStore(IdentityContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
_context = context;
Logins = new UserLoginStore<UserLogin>(_context);
Roles = new RoleStore<Role, UserRole>(_context);
Secrets = new UserSecretStore<UserSecret>(_context);
Tokens = new TokenStore<Token>(_context);
UserClaims = new UserClaimStore<UserClaim>(_context);
UserManagement = new UserManagementStore<UserManagement>(_context);
Users = new UserStore<User>(_context);
}
public CustomIdentityStore(System.Data.Entity.DbContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
_context = context;
Logins = new UserLoginStore<CustomUserLogin>(_context);
Roles = new RoleStore<CustomRole, CustomUserRole>(_context);
Secrets = new UserSecretStore<CustomUserSecret>(_context);
Tokens = new TokenStore<CustomToken>(_context);
UserClaims = new UserClaimStore<CustomUserClaim>(_context);
UserManagement = new UserManagementStore<CustomUserManagement>(_context);
Users = new UserStore<CustomUser>(_context);
}
private void TokenStoreTest(string url, string token)
{
try
{
Uri uri = new Uri(url, UriKind.Absolute);
ITokenStore tokenStore = new TokenStore("token-test");
Token writeToken = new Token(token);
Token readToken = null;
tokenStore.WriteToken(uri, writeToken);
if (tokenStore.ReadToken(uri, out readToken))
{
Assert.AreEqual(writeToken.Value, readToken.Value, "Tokens did not match between written and read");
}
else
{
Assert.Fail("Failed to read credentials");
}
tokenStore.DeleteToken(uri);
Assert.IsFalse(tokenStore.ReadToken(uri, out readToken), "Deleted token was read back");
}
catch (Exception exception)
{
Assert.Fail(exception.Message);
}
}
