public object ResolveTokenData(Type dataType, string token)
{
try
{
object result;
TokenStorage tokenStorage = new TokenStorage
{
Token = token.ToString(),
Type = dataType
};
if (_tokenCache.TryGetValue(tokenStorage, out result))
{
return(result);
}
lock (this)
{
result = SafeLoadData(Path.Combine(Application.persistentDataPath,
string.Format("{0}_{1}", Base64Encode(dataType.AssemblyQualifiedName), token)));
_tokenCache[tokenStorage] = result;
return(result);
}
}
catch (Exception)
{
return(dataType.GetDefault());
}
}
public async Task <IHttpActionResult> NewToken(Account account)
{
UserDTO user;
try
{
user = repository.AuthenticateUser(account);
Authentication auth = null;
if (user == null)
{
response = NotFound();
}
else
{
var token = await TokenGenerator.Generate();
auth = new Authentication {
token = token, user = user
};
TokenStorage.GetInstance().SaveToken(auth.token);
response = Ok(auth);
}
}
catch (Exception ex)
{
// Write the excption to a log
response = InternalServerError();
}
return(response);
}
public void StoreExceptionTest()
{
var dataConnection = MockRepository.GenerateStub <IDataConnection>();
var dateHelper = new DateHelper();
var tokenStorage = new TokenStorage(dataConnection, dateHelper);
var userId = 1;
var userIdSalt = new byte[24];
var tokenSalt = new byte[24];
var encryptedGuid = "encrypted-guid";
var encryptedUserId = "dummy-encrypted-user-id";
var issuedAt = new DateTime(2014, 11, 21, 14, 54, 33);
var hashedToken = new PasswordHash.HashInfo
{
Hash = encryptedGuid,
Iterations = 1000,
Method = "sha1",
Salt = Convert.ToBase64String(tokenSalt)
};
// stub fake calls
dataConnection.Stub(x => x.Execute(null, null)).Throw(new Exception()).IgnoreArguments();
Assert.Throws <Exception>(() => tokenStorage.StoreToken(userId, hashedToken, encryptedUserId, userIdSalt, issuedAt));
}
public void RetrieveTokenExceptionTest()
{
// declare mocks
var dataConnection = MockRepository.GenerateStub <IDataConnection>();
// declare objects
var dateHelper = new DateHelper();
var encryptedUserId = "dummy-encrypted-user-id";
var tokenStorage = new TokenStorage(dataConnection, dateHelper);
// stub fake calls
dataConnection.Stub(x => x.Query <TokenStorage.TokenStorageDb>(null, null)).Throw(new Exception()).IgnoreArguments();
PasswordHash.HashInfo hashedTokenResult;
string encryptedUserIdResult;
byte[] userIdSaltResult;
DateTime issuedAtResult;
DateTime refreshedResult;
var result = tokenStorage.RetrieveToken(encryptedUserId, out hashedTokenResult, out encryptedUserIdResult, out userIdSaltResult, out issuedAtResult, out refreshedResult);
Assert.IsFalse(result);
}
public void GenerateToken()
{
var token = TokenGenerator.GenerateToken("1231", "54654", 123);
TokenStorage.StoreToken(token);
var token1 = TokenStorage.GetData(token.Token);
}
// PUT: api/Login/5
public async Task <IHttpActionResult> PostAsync([FromBody] Authentication login)
{
IHttpActionResult response = null;
AuthenticatedUser authUser;
try
{
authUser = repository.AuthenticateUser(login);
if (authUser == null)
{
response = Content(HttpStatusCode.NotFound, "User not found");;
}
else
{
var token = await TokenGenerator.Generate();
authUser.Token = token;
TokenStorage.GetInstance().SaveToken(authUser.Token);
response = Ok(authUser);
}
}
catch (Exception ex)
{
// Write the excption to a log
response = InternalServerError();
}
return(response);
}
private void InitNode(IPEndPoint ipEndpoint)
{
_server = new NodeServer(ipEndpoint);
_server.OnMaliciousMessage += CheckPossibleMaliciousMessage;
_tokenStorage = new TokenStorage();
BucketList = new BucketList(Id, 20);
Storage = new MemoryInfoHashStorage(20);
_server.Start(this);
}
private async Task SetAuthorizationAsync(string bearerToken, bool isPersistent, bool isStore = true)
{
BearerToken = bearerToken;
Api.Authorization = new AuthenticationHeaderValue("Bearer", bearerToken);
if (isStore)
{
await TokenStorage.SetAsync(bearerToken, isPersistent);
}
UserProperties.ClearOnUserChanged();
UserChanged?.Invoke();
}
private async Task ClearAuthorizationAsync()
{
if (BearerToken != null)
{
BearerToken = null;
UserId = null;
UserName = null;
Api.Authorization = null;
await TokenStorage.ClearAsync();
UserChanged?.Invoke();
UserInfoChanged?.Invoke();
}
}
public IHttpActionResult PutAsync([FromBody] Model.AuthenticatedUser login)
{
try
{
TokenStorage.GetInstance().RemoveToken(login.Token);
AuthenticatedUser authUser = new AuthenticatedUser();
return(Ok(authUser));
}
catch (Exception ex)
{
// Write the excption to a log
return(InternalServerError());
}
}
protected override async Task OnInitializedAsync()
{
Navigator.LocationChanged += OnLocationChanged;
string token = Navigator.FindQueryParameter("token");
if (!String.IsNullOrEmpty(token))
{
IsTokenProcessing = true;
try
{
var response = await Api.LoginWithTokenAsync(new LoginWithTokenRequest()
{
Token = token
});
if (LoadUserInfo(response.BearerToken))
{
await SetAuthorizationAsync(response.BearerToken, false);
}
Navigator.OpenTimeline();
}
catch (AggregateException e) when(e.InnerException is HttpRequestException http && http.StatusCode == HttpStatusCode.NotFound)
{
Console.WriteLine(e.GetType().FullName);
Navigator.OpenLogin();
}
finally
{
IsTokenProcessing = false;
}
}
if (BearerToken == null)
{
string bearerToken = await TokenStorage.FindAsync();
if (LoadUserInfo(bearerToken))
{
await SetAuthorizationAsync(bearerToken, false, false);
}
}
initializationSource.SetResult(null);
await base.OnInitializedAsync();
}
public HomeController(TokenStorage tokenStorage)
{
_tokenStorage = tokenStorage;
Connection c = new Connection();
if (c.Database.EnsureCreated())
{
_con = c;
_db = new Database(c);
}
else
{
throw new Exception("A white little polar animal has come!");
}
}
public async Task OnTurn(ITurnContext context, MiddlewareSet.NextDelegate next)
{
var authToken = TokenStorage.LoadConfiguration(context.Activity.Conversation.Id);
if (authToken == null)
{
if (context.Activity.UserHasJustSentMessage() || context.Activity.UserHasJustJoinedConversation())
{
var conversationReference = TurnContext.GetConversationReference(context.Activity);
var serializedCookie = WebUtility.UrlEncode(JsonConvert.SerializeObject(conversationReference));
var signInUrl = AzureAdExtensions.GetUserConsentLoginUrl(AzureAdTenant, AppClientId, AppRedirectUri, PermissionsRequested, serializedCookie);
var activity = context.Activity.CreateReply();
activity.AddSignInCard(signInUrl);
await context.SendActivity(activity);
}
}
else if (authToken.ExpiresIn < DateTime.Now.AddMinutes(-10))
{
if (context.Activity.UserHasJustSentMessage() || context.Activity.UserHasJustJoinedConversation())
{
var client = new HttpClient();
var accessToken = await AzureAdExtensions.GetAccessTokenUsingRefreshToken(client, AzureAdTenant, authToken.RefreshToken, AppClientId, AppRedirectUri, AppClientSecret, PermissionsRequested);
// have to save it
authToken = new ConversationAuthToken(context.Activity.Conversation.Id)
{
AccessToken = accessToken.accessToken,
RefreshToken = accessToken.refreshToken,
ExpiresIn = accessToken.refreshTokenExpiresIn
};
TokenStorage.SaveConfiguration(authToken);
// make the authtoken available to downstream pipeline components
context.Services.Add(AUTH_TOKEN_KEY, authToken);
await next();
}
}
else
{
// make the authtoken available to downstream pipeline components
context.Services.Add(AUTH_TOKEN_KEY, authToken);
await next();
}
}
public void RefreshTokenTest()
{
var dataConnection = new DataConnection();
var dateHelper = new DateHelper();
var tokenStorage = new TokenStorage(dataConnection, dateHelper);
var userId = 101;
var userIdSalt = new byte[24];
var tokenSalt = new byte[24];
var encryptedGuid = "encrypted-guid";
var encryptedUserId = "dummy-encrypted-user-id";
var issuedAt = new DateTime(2014, 11, 21, 14, 54, 33);
var hashedToken = new PasswordHash.HashInfo
{
Hash = encryptedGuid,
Iterations = 1000,
Method = "sha1",
Salt = Convert.ToBase64String(tokenSalt)
};
Assert.IsTrue(tokenStorage.StoreToken(userId, hashedToken, encryptedUserId, userIdSalt, issuedAt));
Assert.IsTrue(tokenStorage.RefreshToken(userId, hashedToken.Hash, new DateTime(2014, 11, 21, 15, 55, 22)));
PasswordHash.HashInfo hashedTokenResult;
string encryptedUserIdResult;
byte[] userIdSaltResult;
DateTime issuedAtResult;
DateTime refreshedResult;
var retrieveTokenSuccess = tokenStorage.RetrieveToken(encryptedUserId, out hashedTokenResult, out encryptedUserIdResult, out userIdSaltResult, out issuedAtResult, out refreshedResult);
Assert.IsTrue(retrieveTokenSuccess);
Assert.AreEqual(hashedToken.Salt, hashedTokenResult.Salt);
Assert.AreEqual(hashedToken.Hash, hashedTokenResult.Hash);
Assert.AreEqual(hashedToken.Method, hashedTokenResult.Method);
Assert.AreEqual(encryptedUserId, encryptedUserIdResult);
Assert.AreEqual(userIdSalt, userIdSaltResult);
Assert.AreEqual(new DateTime(2014, 11, 21, 14, 54, 33), issuedAtResult);
Assert.AreEqual(new DateTime(2014, 11, 21, 15, 55, 22), refreshedResult);
// check if using a wrong id/encryptid fails (it should fail)
Assert.IsFalse(tokenStorage.RefreshToken(102, hashedToken.Hash, new DateTime(2014, 11, 21, 15, 55, 22)));
Assert.IsFalse(tokenStorage.RefreshToken(userId, hashedToken.Hash + 'a', new DateTime(2014, 11, 21, 15, 55, 22)));
}
public void StoreAndRetrieveTokenTest()
{
TestHelper.DeleteTestData();
TestHelper.InsertTestData();
var dataConnection = new DataConnection();
var dateHelper = new DateHelper();
var tokenStorage = new TokenStorage(dataConnection, dateHelper);
var userId = 1;
var userIdSalt = new byte[24];
var tokenSalt = new byte[24];
var encryptedGuid = "encrypted-guid";
var encryptedUserId = "dummy-encrypted-user-id";
var issuedAt = new DateTime(2014, 11, 21, 14, 54, 33);
var hashedToken = new PasswordHash.HashInfo
{
Hash = encryptedGuid,
Iterations = 1000,
Method = "sha1",
Salt = Convert.ToBase64String(tokenSalt)
};
Assert.IsTrue(tokenStorage.StoreToken(userId, hashedToken, encryptedUserId, userIdSalt, issuedAt));
PasswordHash.HashInfo hashedTokenResult;
string encryptedUserIdResult;
byte[] userIdSaltResult;
DateTime issuedAtResult;
DateTime refreshedResult;
var retrieveTokenSuccess = tokenStorage.RetrieveToken(encryptedUserId, out hashedTokenResult, out encryptedUserIdResult, out userIdSaltResult, out issuedAtResult, out refreshedResult);
Assert.IsTrue(retrieveTokenSuccess);
Assert.AreEqual(hashedToken.Salt, hashedTokenResult.Salt);
Assert.AreEqual(hashedToken.Hash, hashedTokenResult.Hash);
Assert.AreEqual(hashedToken.Method, hashedTokenResult.Method);
Assert.AreEqual(encryptedUserId, encryptedUserIdResult);
Assert.AreEqual(userIdSalt, userIdSaltResult);
Assert.AreEqual(new DateTime(2014, 11, 21, 14, 54, 33), issuedAtResult);
Assert.AreEqual(new DateTime(2014, 11, 21, 14, 54, 33), refreshedResult);
}
public void VerifyTokenExistenceTest()
{
TestHelper.DeleteTestData();
TestHelper.InsertTestData();
//VerifyTokenExistence
var dataConnection = new DataConnection();
var dateHelper = new DateHelper();
var tokenStorage = new TokenStorage(dataConnection, dateHelper);
var userId = 101;
var userIdSalt = new byte[24];
var tokenSalt = new byte[24];
var encryptedGuid = "encrypted-guid";
var encryptedUserId = "dummy-encrypted-user-id";
var issuedAt = new DateTime(2014, 11, 21, 14, 54, 33);
var hashedToken = new PasswordHash.HashInfo
{
Hash = encryptedGuid,
Iterations = 1000,
Method = "sha1",
Salt = Convert.ToBase64String(tokenSalt)
};
Assert.IsTrue(tokenStorage.StoreToken(userId, hashedToken, encryptedUserId, userIdSalt, issuedAt));
string hashedTokenResult;
DateTime issuedAtResult;
DateTime refreshedResult;
var verifyTokenSuccess = tokenStorage.VerifyTokenExistence(userId, out hashedTokenResult, out issuedAtResult, out refreshedResult);
Assert.IsTrue(verifyTokenSuccess);
Assert.AreEqual(encryptedGuid, hashedTokenResult);
Assert.AreEqual(new DateTime(2014, 11, 21, 14, 54, 33), issuedAtResult);
Assert.AreEqual(new DateTime(2014, 11, 21, 14, 54, 33), refreshedResult);
verifyTokenSuccess = tokenStorage.VerifyTokenExistence(102, out hashedTokenResult, out issuedAtResult, out refreshedResult);
Assert.IsFalse(verifyTokenSuccess);
Assert.AreEqual(null, hashedTokenResult);
Assert.AreEqual(new DateTime(), issuedAtResult);
Assert.AreEqual(new DateTime(), refreshedResult);
}
static void Main(string[] args)
{
try
{
ITokenStorage tokenStorage = new TokenStorage();
IEnumerable <ResourceType> resourceTypes = Enum.GetValues(typeof(ResourceType)).Cast <ResourceType>();
foreach (ResourceType resourceType in resourceTypes)
{
string accessToken = tokenStorage.GetAccessToken(resourceType);
DisplayAccessToken(resourceType, accessToken);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("Please enter any key to exit...");
Console.ReadKey();
}
public virtual PowerTableRequest ExtractRequest(ControllerContext context)
{
if (_request != null)
{
return(_request);
}
if (context.HttpContext.Request.HttpMethod == "GET")
{
var token = context.HttpContext.Request.QueryString["q"];
_request = TokenStorage.Lookup(token);
return(_request);
}
var request = context.RequestContext.HttpContext.Request;
request.InputStream.Seek(0, SeekOrigin.Begin);
string jsonData = new StreamReader(request.InputStream).ReadToEnd();
_request = JsonConvert.DeserializeObject <PowerTableRequest>(jsonData);
_request.Configurator = _configuration;
return(_request);
}
protected bool Equals(TokenStorage other)
{
return(Equals(Type, other.Type) && string.Equals(Token, other.Token));
}
