private static string CreateExpiredToken()
{
var jwtProvider = (JwtAuthProvider)AuthenticateService.GetAuthProvider(JwtAuthProviderReader.Name);
jwtProvider.CreatePayloadFilter = (jwtPayload, session) =>
jwtPayload["exp"] = DateTime.UtcNow.AddSeconds(-1).ToUnixTime().ToString();
var token = jwtProvider.CreateJwtBearerToken(new AuthUserSession
{
UserAuthId = "1",
DisplayName = "Test",
Email = "*****@*****.**"
});
jwtProvider.CreatePayloadFilter = null;
return(token);
}
public static IAuthSession GetSession(this IRequest httpReq, bool reload = false)
{
if (httpReq == null)
{
return(null);
}
object oSession = null;
if (!reload)
{
httpReq.Items.TryGetValue(RequestItemsSessionKey, out oSession);
}
if (oSession != null)
{
return((IAuthSession)oSession);
}
using (var cache = httpReq.GetCacheClient())
{
var sessionId = httpReq.GetSessionId();
var session = cache.Get <IAuthSession>(SessionFeature.GetSessionKey(sessionId));
if (session == null)
{
session = AuthenticateService.CurrentSessionFactory();
session.Id = sessionId;
session.CreatedAt = session.LastModified = DateTime.UtcNow;
session.OnCreated(httpReq);
var authEvents = HostContext.TryResolve <IAuthEvents>();
if (authEvents != null)
{
authEvents.OnCreated(httpReq, session);
}
}
if (httpReq.Items.ContainsKey(RequestItemsSessionKey))
{
httpReq.Items.Remove(RequestItemsSessionKey);
}
httpReq.Items.Add(RequestItemsSessionKey, session);
return(session);
}
}
public void Register(IAppHost appHost)
{
hasRegistered = true;
AuthenticateService.Init(sessionFactory, authProviders);
var unitTest = appHost == null;
if (unitTest)
{
return;
}
if (HostContext.StrictMode)
{
var sessionInstance = sessionFactory();
if (TypeSerializer.HasCircularReferences(sessionInstance))
{
throw new StrictModeException($"User Session {sessionInstance.GetType().Name} cannot have circular dependencies", "sessionFactory",
StrictModeCodes.CyclicalUserSession);
}
}
foreach (var registerService in ServiceRoutes)
{
appHost.RegisterService(registerService.Key, registerService.Value);
}
var sessionFeature = RegisterPlugins.OfType <SessionFeature>().First();
sessionFeature.SessionExpiry = SessionExpiry;
sessionFeature.PermanentSessionExpiry = PermanentSessionExpiry;
appHost.LoadPlugin(RegisterPlugins.ToArray());
if (IncludeAuthMetadataProvider && appHost.TryResolve <IAuthMetadataProvider>() == null)
{
appHost.Register <IAuthMetadataProvider>(new AuthMetadataProvider());
}
authProviders.OfType <IAuthPlugin>().Each(x => x.Register(appHost, this));
AuthenticateService.HtmlRedirect = HtmlRedirect;
AuthenticateService.HtmlRedirectReturnParam = HtmlRedirectReturnParam;
AuthenticateService.HtmlRedirectReturnPathOnly = HtmlRedirectReturnPathOnly;
AuthenticateService.AuthResponseDecorator = AuthResponseDecorator;
}
public static IAuthSession CreateNewSession(IRequest httpReq, string sessionId)
{
var session = AuthenticateService.CurrentSessionFactory();
session.Id = sessionId ?? CreateSessionIds(httpReq);
session.CreatedAt = session.LastModified = DateTime.UtcNow;
session.OnCreated(httpReq);
var authEvents = HostContext.TryResolve <IAuthEvents>();
if (authEvents != null)
{
authEvents.OnCreated(httpReq, session);
}
return(session);
}
public static bool Authenticate(IRequest req, object requestDto = null, IAuthSession session = null, IAuthProvider[] authProviders = null)
{
if (HostContext.HasValidAuthSecret(req))
{
return(true);
}
session ??= (req ?? throw new ArgumentNullException(nameof(req))).GetSession();
authProviders ??= AuthenticateService.GetAuthProviders();
var authValidate = HostContext.GetPlugin <AuthFeature>()?.OnAuthenticateValidate;
var ret = authValidate?.Invoke(req);
if (ret != null)
{
return(false);
}
req.PopulateFromRequestIfHasSessionId(requestDto);
if (!req.Items.ContainsKey(Keywords.HasPreAuthenticated))
{
var mockResponse = new BasicRequest().Response;
req.Items[Keywords.HasPreAuthenticated] = true;
foreach (var authWithRequest in authProviders.OfType <IAuthWithRequest>())
{
authWithRequest.PreAuthenticateAsync(req, mockResponse).Wait();
if (mockResponse.IsClosed)
{
return(false);
}
}
foreach (var authWithRequest in authProviders.OfType <IAuthWithRequestSync>())
{
authWithRequest.PreAuthenticate(req, mockResponse);
if (mockResponse.IsClosed)
{
return(false);
}
}
}
return(session != null && (authProviders.Length > 0
? authProviders.Any(x => session.IsAuthorized(x.Provider))
: session.IsAuthenticated));
}
public static int GetCount(string FilePath, int portalID, string userName, int userModuleID, string secureToken)
{
AuthenticateService objService = new AuthenticateService();
int numFiles = 0;
if (objService.IsPostAuthenticatedView(portalID, userModuleID, userName, secureToken))
{
if (FilePath == "/")
{
FilePath = HttpContext.Current.Server.MapPath("~/");
}
string[] files;
files = Directory.GetFiles(FilePath);
numFiles = files.Length;
}
return(numFiles);
}
public override async Task ExecuteAsync(IRequest req, IResponse res, object requestDto)
{
if (AuthenticateService.AuthProviders == null)
{
throw new InvalidOperationException(
"The AuthService must be initialized by calling AuthService.Init to use an authenticate attribute");
}
if (HostContext.HasValidAuthSecret(req))
{
return;
}
var authProviders = AuthenticateService.GetAuthProviders(this.Provider);
if (authProviders.Length == 0)
{
await res.WriteError(req, requestDto, $"No registered Auth Providers found matching {this.Provider ?? "any"} provider").ConfigAwait();
res.EndRequest();
return;
}
req.PopulateFromRequestIfHasSessionId(requestDto);
await PreAuthenticateAsync(req, authProviders).ConfigAwait();
if (res.IsClosed)
{
return;
}
var session = req.GetSession();
if (session == null || !authProviders.Any(x => session.IsAuthorized(x.Provider)))
{
if (this.DoHtmlRedirectIfConfigured(req, res, true))
{
return;
}
await AuthProvider.HandleFailedAuth(authProviders[0], session, req, res).ConfigAwait();
}
}
public void Does_validate_multiple_audiences()
{
var jwtProvider = (JwtAuthProvider)AuthenticateService.GetAuthProvider(JwtAuthProviderReader.Name);
string CreateJwtWithAudiences(params string[] audiences)
{
var header = JwtAuthProvider.CreateJwtHeader(jwtProvider.HashAlgorithm);
var body = JwtAuthProvider.CreateJwtPayload(new AuthUserSession
{
UserAuthId = "1",
DisplayName = "Test",
Email = "*****@*****.**",
IsAuthenticated = true,
},
issuer: jwtProvider.Issuer,
expireIn: jwtProvider.ExpireTokensIn,
audiences: audiences);
var jwtToken = JwtAuthProvider.CreateJwt(header, body, jwtProvider.GetHashAlgorithm());
return(jwtToken);
}
jwtProvider.Audiences = new List <string> {
"foo", "bar"
};
var jwtNoAudience = CreateJwtWithAudiences();
Assert.That(jwtProvider.IsJwtValid(jwtNoAudience));
var jwtWrongAudience = CreateJwtWithAudiences("qux");
Assert.That(!jwtProvider.IsJwtValid(jwtWrongAudience));
var jwtPartialAudienceMatch = CreateJwtWithAudiences("bar", "qux");
Assert.That(jwtProvider.IsJwtValid(jwtPartialAudienceMatch));
jwtProvider.Audience = "foo";
Assert.That(!jwtProvider.IsJwtValid(jwtPartialAudienceMatch));
jwtProvider.Audience = null;
Assert.That(jwtProvider.IsJwtValid(jwtPartialAudienceMatch));
}
public void Register(IAppHost appHost)
{
AuthenticateService.Init(sessionFactory, authProviders);
AuthenticateService.HtmlRedirect = HtmlRedirect;
var unitTest = appHost == null;
if (unitTest)
{
return;
}
foreach (var registerService in ServiceRoutes)
{
appHost.RegisterService(registerService.Key, registerService.Value);
}
RegisterPlugins.ForEach(x => appHost.LoadPlugin(x));
}
public static RegisterService GetRegistrationService(
IUserAuthRepository userAuthRepository,
AuthUserSession oAuthUserSession = null,
BasicRequest request = null)
{
if (request == null)
{
request = new BasicRequest();
}
if (oAuthUserSession == null)
{
oAuthUserSession = request.ReloadSession();
}
oAuthUserSession.Id = request.Response.CreateSessionId(request);
request.Items[SessionFeature.RequestItemsSessionKey] = oAuthUserSession;
var mockAppHost = new BasicAppHost();
mockAppHost.Container.Register <IAuthRepository>(userAuthRepository);
var authService = new AuthenticateService
{
Request = request,
};
authService.SetResolver(mockAppHost);
mockAppHost.Register(authService);
var registrationService = new RegisterService
{
AuthRepo = userAuthRepository,
Request = request,
RegistrationValidator =
new RegistrationValidator {
UserAuthRepo = RegistrationServiceTests.GetStubRepo()
},
};
registrationService.SetResolver(mockAppHost);
return(registrationService);
}
public void Authenticate()
{
User result = null;
using (var db = new MainAuthExampleContext(_options))
{
if (!db.Users.Where(u => u.Username.Equals("user1")).Any())
{
db.Users.Add(new UserAuthenticationsEntity {
Username = "******", Password = "******"
});
db.SaveChanges();
}
var authService = new AuthenticateService(db);
result = authService.Authenticate(new AnonymousUser("user1", "pass1"));
}
Assert.Equal(new Employee("user1"), result);
}
public void Can_validate_valid_token()
{
var authClient = GetClient();
var jwt = authClient.Send(new Authenticate
{
provider = "credentials",
UserName = Username,
Password = Password,
}).BearerToken;
var jwtProvider = AuthenticateService.GetJwtAuthProvider();
Assert.That(jwtProvider.IsJwtValid(jwt));
var jwtPayload = jwtProvider.GetValidJwtPayload(jwt);
Assert.That(jwtPayload, Is.Not.Null);
Assert.That(jwtPayload["preferred_username"], Is.EqualTo(Username));
}
public virtual string GetConsumerId(IRequest request)
{
if (AuthenticateService.GetAuthProviders() == null)
{
throw new InvalidOperationException(
"AuthService not initialized. This is required for generating default ConsumerId for RateLimitting.");
}
IAuthSession userSession = request.GetSession();
// TODO This will need more love to authorize user rather than just verify authentication (not necessarily here but in general)
if (!IsUserAuthenticated(userSession))
{
log.Error($"User {userSession?.UserName ?? "<unknown>"} not authenticated for request {request.AbsoluteUri}");
throw new AuthenticationException("You must be authenticated to access this service");
}
return(userSession.UserAuthId?.ToLowerInvariant());
}
public object Any(CreateJwt request)
{
var jwtProvider = (JwtAuthProvider)AuthenticateService.GetAuthProvider(JwtAuthProvider.Name);
if (request.JwtExpiry != null)
{
jwtProvider.CreatePayloadFilter = (jwtPayload, session) =>
jwtPayload["exp"] = request.JwtExpiry.Value.ToUnixTime().ToString();
}
var jwtSession = request.ConvertTo <AuthUserSession>();
var token = jwtProvider.CreateJwtBearerToken(jwtSession);
jwtProvider.CreatePayloadFilter = null;
return(new CreateJwtResponse
{
Token = token
});
}
public static void CopyFile(string filePath, string fromPath, string toPath, int portalID, string userName, int userModuleID, string secureToken)
{
AuthenticateService objService = new AuthenticateService();
if (objService.IsPostAuthenticatedView(portalID, userModuleID, userName, secureToken))
{
string fullFilePath = GetAbsolutePath(filePath);
string fullFromPath = GetAbsolutePath(fromPath);
string fullToPath = GetAbsolutePath(toPath);
try
{
//public static void TransferFile(string filePath, string toPath, int action, int mode, string fullFilePath, string fullFromPath, string fullToPath)
FileManagerHelper.TransferFile(filePath, toPath, (int)Action.COPY, (int)TransferMode.NORMALTONORMAL, fullFilePath, fullFromPath, fullToPath);
}
catch (Exception ex)
{
fb.ProcessException(ex);
}
}
}
public static bool IsAuthenticated(this IRequest req)
{
//Sync with [Authenticate] impl
if (HostContext.HasValidAuthSecret(req))
{
return(true);
}
var authProviders = AuthenticateService.GetAuthProviders();
AuthenticateAttribute.PreAuthenticate(req, authProviders);
if (req.Response.IsClosed)
{
return(false);
}
var session = req.GetSession();
return(session != null && authProviders.Any(x => session.IsAuthorized(x.Provider)));
}
public static string UnzipFiles(string FilePath, int FolderID, int portalID, string userName, int userModuleID, string secureToken)
{
StringBuilder sb = new StringBuilder();
AuthenticateService objService = new AuthenticateService();
if (objService.IsPostAuthenticatedView(portalID, userModuleID, userName, secureToken))
{
string absolutePath = GetAbsolutePath(FilePath);
FileInfo file = new FileInfo(absolutePath);
string folderName = file.Name;
string newFolderPath = FileManagerHelper.GetFilePathWithoutExtension(absolutePath);
DirectoryInfo dir = new DirectoryInfo(newFolderPath);
if (!dir.Exists)
{
string path = string.Empty;
FileManagerHelper.UnZipFiles(absolutePath, newFolderPath, ref path, SageFrame.Common.RegisterModule.Common.Password, false, userModuleID, fb.GetPortalID);
Folder folder = new Folder();
folder.PortalId = fb.GetPortalID;
folder.ParentID = FolderID;
folder.FolderPath = FileManagerHelper.ReplaceBackSlash(FileManagerHelper.GetFilePathWithoutExtension(FilePath));
folder.StorageLocation = 0;
folder.UniqueId = Guid.NewGuid();
folder.VersionGuid = Guid.NewGuid();
folder.IsActive = 1;
folder.IsRoot = false;
folder.AddedBy = fb.GetUsername;
try
{
int folderID = FileManagerController.AddFolderReturnFolderID(folder);
RecurseThroughDirectory(dir, folderID, userModuleID, ref sb);
}
catch (Exception ex)
{
fb.ProcessException(ex);
}
}
CacheHelper.Clear("FileManagerFileList");
CacheHelper.Clear("FileManagerFolders");
}
return(sb.ToString());
}
public static void AuthenticateIfBasicAuth(IRequest req, IResponse res)
{
//Need to run SessionFeature filter since its not executed before this attribute (Priority -100)
SessionFeature.AddSessionIdToRequestFilter(req, res, null); //Required to get req.GetSessionId()
var userPass = req.GetBasicAuthUserAndPassword();
if (userPass != null)
{
AuthenticateService authService = req.TryResolve <AuthenticateService>();
//authService.Request = new HttpRequestContext(req, res, null);
//var response = authService.Post(new Authenticate
authService.Post(new Authenticate
{
provider = "credentials",
UserName = userPass.Value.Key,
Password = userPass.Value.Value
});
}
}
public async Task InvalidUser_FailsLogin()
{
// Arrange
AccountLoginModel model = new AccountLoginModel {
Email = SOME_EMAIL,
Password = SOME_PASSWORD
};
UserLoginResponse userRepoResult = new UserLoginResponse {
UserIsValid = false
};
// Setup mock
Mock <IUserRepository> userRepositoryMock = SetupUserRepositoryMock(userRepoResult);
// Act
AuthenticateService service = new AuthenticateService(userRepositoryMock.Object);
AuthenticateResult results = await service.AuthenticateUser(model);
// Assert
results.Identity.Should().Be(null);
}
/// <summary>
/// Method to Fetch API Version
/// </summary>
/// <param name="dataAccessToken"></param>
/// <returns></returns>
public string GetAPIVersion(string dataAccessToken)
{
string apiVersion = string.Empty;
string encryptedDataAccessToken = string.Empty;
AuthenticateService integrationService = new AuthenticateService();
try
{
apiVersion = integrationService.GetAPIVersion(Constants.CONSUMER_SECRET_TOKEN, UtilityService.DecryptedText(dataAccessToken), Constants.VERSION_5);
}
catch (DovicoException e)
{
logger.Log(LogLevel.Error, e);
}
catch (Exception e)
{
logger.Log(LogLevel.Error, e);
}
return(apiVersion);
}
public Task <ActionResult> Register(RegisterViewModel viewModel)
{
return(CreateActionResultAsync(async() =>
{
if (!ModelState.IsValid)
{
return View();
}
var dtoAccount =
Mapper.Map <RegisterViewModel, AccountDTO>(viewModel);
AccountService.Create(dtoAccount);
var claims = await AuthenticateService.Authenticate(dtoAccount);
SignIn(claims);
return RedirectToAction("Index", "Home");
}));
}
public static string ReadFiles(string FullPath, int portalID, string userName, int userModuleID, string secureToken)
{
string html = string.Empty;
AuthenticateService objService = new AuthenticateService();
if (objService.IsPostAuthenticatedView(portalID, userModuleID, userName, secureToken))
{
try
{
int index = 0;
index = HttpContext.Current.Request.ApplicationPath == "/" ? 0 : 1;
string originalFile = string.Concat(HttpContext.Current.Server.MapPath("~/"), FullPath.Substring(FullPath.IndexOf("/", index)).Replace("/", "\\"));
html = GetXMLString(originalFile, portalID, userName, userModuleID, secureToken);
}
catch (Exception e)
{
throw e;
}
}
return(html);
}
public async Task Login_InValid_Returns_False()
{
// Arrange
var userList = new List <User>();
var mockUser = userList.AsQueryable().BuildMock();
_Repo.Setup(x => x.Get(It.IsAny <Expression <Func <User, bool> > >())).Returns(mockUser.Object);
var request = new SignInRequest {
Username = "******", Password = "******"
};
var tokenBuilder = new Mock <ITokenBuilderService>();
var passwordService = new Mock <IPasswordService>();
var authService = new AuthenticateService(_Repo.Object, tokenBuilder.Object, passwordService.Object);
// Act
var results = await authService.Authenticate(request);
// Assert
Assert.IsFalse(results.Success);
}
/// <summary>
/// Configure ServiceStack Authentication plugin.
/// </summary>
/// <param name="container">The container.</param>
private void ConfigureAuth(Container container)
{
Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[]
{
new BasicAuthProvider(AppSettings),
new ApiKeyAuthProvider(AppSettings),
}));
var authRepo = new OrmLiteAuthRepository(container.Resolve <IDbConnectionFactory>());
container.Register <IAuthRepository>(c => authRepo);
authRepo.InitSchema();
5.Times(x => authRepo.CreateUserAuth(new UserAuth {
UserName = $"user{x}",
Email = $"user{x}@email.com",
}, "test"));
AfterInitCallbacks.Add(host =>
{
var authProvider = (ApiKeyAuthProvider)
AuthenticateService.GetAuthProvider(ApiKeyAuthProvider.Name);
using (var db = host.TryResolve <IDbConnectionFactory>().Open())
{
var userWithKeysIds = db.Column <string>(db.From <ApiKey>()
.SelectDistinct(x => x.UserAuthId)).Map(int.Parse);
var userIdsMissingKeys = db.Column <string>(db.From <UserAuth>()
.Where(x => userWithKeysIds.Count == 0 || !userWithKeysIds.Contains(x.Id))
.Select(x => x.Id));
foreach (var userId in userIdsMissingKeys)
{
var apiKeys = authProvider.GenerateNewApiKeys(userId.ToString());
authRepo.StoreAll(apiKeys);
}
}
});
}
public static void CreateFolder(int FolderID, string filePath, string folderName, int fileType, int portalID, string userName, int userModuleID, string secureToken)
{
AuthenticateService objService = new AuthenticateService();
if (objService.IsPostAuthenticatedView(portalID, userModuleID, userName, secureToken))
{
string absolutePath = FileManagerHelper.ReplaceBackSlash(Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath.ToString(), filePath));
DirectoryInfo dir = new DirectoryInfo(absolutePath);
if (!dir.Exists)
{
dir.Create();
try
{
CacheHelper.Clear("FileManagerFolders");
}
catch (Exception ex)
{
fb.ProcessException(ex);
}
}
}
}
public static string PostToUrl(string url, string accessToken, string accessTokenSecret, Dictionary <string, string> args, string acceptType = MimeTypes.Json)
{
var oAuthProvider = (OAuthProvider)AuthenticateService.GetAuthProvider("twitter");
var uri = new Uri(url);
var webReq = (HttpWebRequest)WebRequest.Create(uri);
webReq.Accept = acceptType;
webReq.Method = HttpMethods.Post;
string data = null;
if (args != null)
{
var sb = new StringBuilder();
foreach (var arg in args)
{
if (sb.Length > 0)
{
sb.Append("&");
}
sb.AppendFormat("{0}={1}", arg.Key, OAuthUtils.PercentEncode(arg.Value));
}
data = sb.ToString();
}
webReq.Headers[HttpRequestHeader.Authorization] = OAuthAuthorizer.AuthorizeRequest(
oAuthProvider, accessToken, accessTokenSecret, "POST", uri, data);
if (data != null)
{
webReq.ContentType = MimeTypes.FormUrlEncoded;
using (var writer = new StreamWriter(webReq.GetRequestStream()))
writer.Write(data);
}
using (var webRes = webReq.GetResponse())
return(webRes.ReadToEnd());
}
public object Any(CreateRefreshJwt request)
{
var jwtProvider = (JwtAuthProvider)AuthenticateService.GetAuthProvider(JwtAuthProvider.Name);
var jwtHeader = new JsonObject
{
{ "typ", "JWTR" }, //RefreshToken
{ "alg", jwtProvider.HashAlgorithm }
};
var keyId = jwtProvider.GetKeyId(Request);
if (keyId != null)
{
jwtHeader["kid"] = keyId;
}
var now = DateTime.UtcNow;
var jwtPayload = new JsonObject
{
{ "sub", request.UserAuthId ?? "1" },
{ "iat", now.ToUnixTime().ToString() },
{ "exp", (request.JwtExpiry ?? DateTime.UtcNow.AddDays(1)).ToUnixTime().ToString() },
};
if (jwtProvider.Audience != null)
{
jwtPayload["aud"] = jwtProvider.Audience;
}
var hashAlgoritm = jwtProvider.GetHashAlgorithm();
var refreshToken = JwtAuthProvider.CreateJwt(jwtHeader, jwtPayload, hashAlgoritm);
return(new CreateRefreshJwtResponse
{
Token = refreshToken
});
}
protected async Task HandleDeleteButton()
{
var options = new ModalOptions()
{
DisableBackgroundCancel = true,
HideCloseButton = true
};
var modal = Modal.Show <DeleteUserConfirmation>("Delete User", options);
var result = await modal.Result;
if (!result.Cancelled && User != null)
{
await AuthenticateService.LogoutUser();
var succeeded = await UserService.DeleteUserAsync(User.Id);
if (succeeded)
{
NavigationManager.NavigateTo("/");
}
}
}
public static string UnzipFiles(string FilePath, int FolderID, int portalID, string userName, int userModuleID, string secureToken)
{
StringBuilder sb = new StringBuilder();
AuthenticateService objService = new AuthenticateService();
if (objService.IsPostAuthenticatedView(portalID, userModuleID, userName, secureToken))
{
string absolutePath = GetAbsolutePath(FilePath);
FileInfo file = new FileInfo(absolutePath);
string folderName = file.Name;
string newFolderPath = FileManagerHelper.GetFilePathWithoutExtension(absolutePath);
DirectoryInfo dir = new DirectoryInfo(newFolderPath);
if (!dir.Exists)
{
string path = string.Empty;
FileManagerHelper.UnZipFiles(absolutePath, newFolderPath, ref path, SageFrame.Common.RegisterModule.Common.Password, false, userModuleID, fb.GetPortalID);
Folder folder = new Folder();
}
CacheHelper.Clear("FileManagerFileList");
CacheHelper.Clear("FileManagerFolders");
}
return(sb.ToString());
}
public void Can_not_access_Secure_service_with_invalidated_token()
{
var jwtProvider = (JwtAuthProvider)AuthenticateService.GetAuthProvider(JwtAuthProvider.Name);
var token = jwtProvider.CreateJwtBearerToken(new AuthUserSession
{
UserAuthId = "1",
DisplayName = "Test",
Email = "*****@*****.**"
});
var client = GetClientWithBearerToken(token);
var request = new Secured {
Name = "test"
};
var response = client.Send(request);
Assert.That(response.Result, Is.EqualTo(request.Name));
jwtProvider.InvalidateTokensIssuedBefore = DateTime.UtcNow.AddSeconds(1);
try
{
response = client.Send(request);
Assert.Fail("Should throw");
}
catch (WebServiceException ex)
{
Assert.That(ex.StatusCode, Is.EqualTo((int)HttpStatusCode.Unauthorized));
Assert.That(ex.ErrorCode, Is.EqualTo(typeof(TokenException).Name));
}
finally
{
jwtProvider.InvalidateTokensIssuedBefore = null;
}
}
public bool Authenticate(string username, string password)
{
//Run auth through the auth svc to get an identity
AuthenticateService authsvc = new AuthenticateService();
try {
authsvc.Url = String.Format("http://{0}/FrontDeskServices/authsvc.asmx",
TestConfig.AuthenticationAddress);
Authentication.ServiceTicket tik = authsvc.Authenticate(username, password);
FrontDesk.Services.ServiceTicket ticket = new FrontDesk.Services.ServiceTicket();
ticket.HostAddress = tik.HostAddress;
ticket.Username = tik.Username;
ticket.Ident = tik.Ident;
m_ident = AuthorizedIdent.Create(ticket);
if (m_ident != null) {
m_logger.Log("Authentication for: " + username +
" succeeded.");
return true;
}
else {
m_logger.Log("Authentication for: " + username +
" failed.", TestLogger.LogType.ERROR);
return false;
}
} catch (Exception er) {
m_logger.Log("Error during authentication: MESSAGE: " + er.Message,
TestLogger.LogType.ERROR);
return false;
}
}
