public HttpResponseMessage SetupGoogleAuth()
{
var databaseSettings = CustomDatabase.GetSettingsFromDatabase();
if (!databaseSettings.GoogleAuthenticator_Enabled)
{
throw new Exception("Google Authenticator is disabled");
}
//var user = SignInManager.AuthenticationManager.User.Identity.Name;
//SignInManager.AuthenticationManager.AuthenticationResponseGrant.Identity.Name
var userId = (HttpContext.Current.Session["TWOFACTORUSER"] as int?).Value;
TwoFactorAuthenticator tfa = new TwoFactorAuthenticator();
var secretKey = Guid.NewGuid().ToString().Replace("-", "").Substring(0, 10);
var setupInfo = tfa.GenerateSetupCode(CustomDatabase.GetSettingsFromDatabase().GoogleAuthenticator_Name, userId.ToString(), secretKey, 300, 300);
var details = CustomDatabase.GetUserDetails(userId);
if (details != null && details.IsValidated)
{
throw new UnauthorizedAccessException("This account has already setup GoogleAuthenticator");
}
var isNew = details == null;
details = new FortressUser2FASettings();
details.UserId = userId;
details.Provider = "GoogleAuthenticator";
details.Configuration = secretKey;
details.IsValidated = false;
if (isNew)
{
CustomDatabase.Insert(details);
}
else
{
CustomDatabase.Update(details);
}
string qrCodeImageUrl = setupInfo.QrCodeSetupImageUrl;
string manualEntrySetupCode = setupInfo.ManualEntryKey;
var response = Request.CreateResponse(HttpStatusCode.OK, new { image = qrCodeImageUrl, manualEntryCode = manualEntrySetupCode });
return(response);
}
public UserTwoFactorSettings RemoveTwoFactor()
{
var model = new UserTwoFactorSettings();
var userId = Security.GetUserId();
var details = CustomDatabase.GetUserDetails(userId);
if (details == null || !details.IsValidated)
{
throw new UnauthorizedAccessException("This account hasnt got authenticator setup");
}
details.IsValidated = false;
CustomDatabase.Update(details);
return(model);
}
public HttpResponseMessage Validate(string code, string token)
{
var userId = SignInManager.GetVerifiedUserId();
var details = CustomDatabase.GetUserDetails(userId);
var result = SignInManager.TwoFactorSignIn(details.Provider, code + ":" + token, true, true);
switch (result)
{
case SignInStatus.Success:
if (!details.IsValidated)
{
details.IsValidated = true;
CustomDatabase.Update(details);
}
//get the user
var user = ApplicationContext.Services.UserService.GetUserById(SignInManager.GetVerifiedUserId());
var userDetail = Mapper.Map <UserDetail>(user);
//update the userDetail and set their remaining seconds
userDetail.SecondsUntilTimeout = TimeSpan.FromMinutes(GlobalSettings.TimeOutInMinutes).TotalSeconds;
//create a response with the userDetail object
var response = Request.CreateResponse(HttpStatusCode.OK, userDetail);
//ensure the user is set for the current request
//Request.SetPrincipalForRequest(user);
//
return(response);
break;
case SignInStatus.LockedOut:
case SignInStatus.Failure:
default:
//return BadRequest (400), we don't want to return a 401 because that get's intercepted
// by our angular helper because it thinks that we need to re-perform the request once we are
// authorized and we don't want to return a 403 because angular will show a warning msg indicating
// that the user doesn't have access to perform this function, we just want to return a normal invalid msg.
throw new HttpResponseException(HttpStatusCode.BadRequest);
break;
}
}
public GoogleAuthenticatorSettingsModel RemoveGoogleAuthenticatorForUser(int id)
{
CheckAuth();
var model = new UserTwoFactorSettings();
var details = CustomDatabase.GetUserDetails(id);
if (details == null || !details.IsValidated)
{
throw new UnauthorizedAccessException("This account hasnt got authenticator setup");
}
details.IsValidated = false;
CustomDatabase.Update(details);
return(GetGoogleAuthenticatorSettings());
}
public TwoFactorSetupOptions SetupAuthenticator()
{
var userId = Security.GetUserId();
var details = CustomDatabase.GetUserDetails(userId);
if (details != null && details.IsValidated)
{
throw new UnauthorizedAccessException("This account has already setup GoogleAuthenticator");
}
TwoFactorAuthenticator tfa = new TwoFactorAuthenticator();
var secretKey = Guid.NewGuid().ToString().Replace("-", "").Substring(0, 10);
var setupInfo = tfa.GenerateSetupCode(CustomDatabase.GetSettingsFromDatabase().GoogleAuthenticator_Name, userId.ToString(), secretKey, 300, 300);
var isNew = details == null;
details = new FortressUser2FASettings();
details.UserId = userId;
details.Provider = "GoogleAuthenticator";
details.Configuration = secretKey;
details.IsValidated = false;
if (isNew)
{
CustomDatabase.Insert(details);
}
else
{
CustomDatabase.Update(details);
}
string qrCodeImageUrl = setupInfo.QrCodeSetupImageUrl;
string manualEntrySetupCode = setupInfo.ManualEntryKey;
var response = new TwoFactorSetupOptions()
{
Image = qrCodeImageUrl,
ManualEntryCode = manualEntrySetupCode
};
return(response);
}
public static void GetInfoDirect(string connectionString)
{
using (var db = new CustomDatabase(connectionString))
{
var svc = GetUserAccountService(db);
var account = svc.GetByUsername("bob");
if (account != null)
{
//When fetching the account the first time, the lastUpdated DateTime Kind is reported as "Unspecified"
Console.WriteLine("From Local: {0} - {1}", account.LastUpdated.ToString("s"),
account.LastUpdated.Kind);
/* This can be used to confirm that as soon as Update() is called, the DateTime.Kind property is updated to Utc
* svc.Update(account);
* Console.WriteLine("With Updte: {0} - {1}", account.LastUpdated.ToString("s"),
* account.LastUpdated.Kind);
*/
}
}
}
public void Remove_IsValid(int[] values)
{
CustomDatabase db = new CustomDatabase(values);
FieldInfo fieldInfo = typeof(CustomDatabase)
.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
.First(fi => fi.FieldType == typeof(int[]));
db.Remove();
int[] targetValues = ((int[])fieldInfo.GetValue(db));
int[] buffer = new int[targetValues.Length - (values.Length - 1)];
values = values
.Take(values.Length - 1)
.Concat(buffer)
.ToArray();
Assert.That(targetValues, Is.EqualTo(values));
}
public static void GetInfoDirect(string connectionString)
{
using (var db = new CustomDatabase(connectionString))
{
var svc = GetUserAccountService(db);
var account = svc.GetByUsername("bob");
if (account != null)
{
//When fetching the account the first time, the lastUpdated DateTime Kind is reported as "Unspecified"
Console.WriteLine("From Local: {0} - {1}", account.LastUpdated.ToString("s"),
account.LastUpdated.Kind);
/* This can be used to confirm that as soon as Update() is called, the DateTime.Kind property is updated to Utc
svc.Update(account);
Console.WriteLine("With Updte: {0} - {1}", account.LastUpdated.ToString("s"),
account.LastUpdated.Kind);
*/
}
}
}
public HttpResponseMessage SetupSMS(string number)
{
var user = SignInManager.GetVerifiedUserId();
var details = CustomDatabase.GetUserDetails(user);
if (details != null && details.IsValidated)
{
throw new UnauthorizedAccessException("This account has already setup SMS");
}
var isNew = details == null;
details = new FortressUser2FASettings();
details.UserId = user;
details.Provider = "SMS";
details.Configuration = number;
details.IsValidated = false;
lock (syncLock)
{
var code = _random.Next(999999).ToString();
details.CurrentCode = code;
details.CurrentCodeGenerated = DateTime.UtcNow;
}
if (isNew)
{
CustomDatabase.Insert(details);
}
else
{
CustomDatabase.Update(details);
}
var settings = CustomDatabase.GetSettingsFromDatabase();
var SmsProvider = FortressContext.GetCurrentSmsProvider();
SmsProvider.SendSms(details.Configuration, string.Format(settings.SMS_MessageFormat, details.CurrentCode));
var response = Request.CreateResponse(HttpStatusCode.OK, new { token = "123456" });
return(response);
}
public void Add_IsValid(int element)
{
CustomDatabase db = new CustomDatabase();
db.Add(element);
FieldInfo fieldInfo = typeof(CustomDatabase)
.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
.First(fi => fi.FieldType == typeof(int[]));
FieldInfo currentIndexInfo = typeof(CustomDatabase)
.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
.First(fi => fi.FieldType == typeof(int));
int firstValues = ((int[])fieldInfo.GetValue(db)).First();
Assert.That(firstValues, Is.EqualTo(element));
int valuesCount = (int)currentIndexInfo.GetValue(db);
Assert.That(valuesCount, Is.EqualTo(1));
}
public List <string> GetAvailableTwoFactorMethods()
{
var databaseSettings = CustomDatabase.GetSettingsFromDatabase();
var providers = UserManager.TwoFactorProviders.Keys.ToList();
var filteredList = new List <string>();
foreach (string provider in providers)
{
if (provider == "GoogleAuthenticator")
{
if (databaseSettings.GoogleAuthenticator_Enabled)
{
filteredList.Add(provider);
}
}
else
{
filteredList.Add(provider);
}
}
return(filteredList);
}
public ActionResult Index(string signin, RegisterUser model)
{
if (ModelState.IsValid)
{
//UserAccountService<CustomUser> dd = new UserAccountService<CustomUser>();
//dd.CreateAccount("", model.Username, "password", model.Email, dateCreated: DateTime.Now, account: model);
//new CustomUserRepository().
//new CustomUserAccountService().CreateUserAccount();
using (var db = new CustomDatabase("MembershipReboot"))
{
var svc = userAccountService; //GetUserAccountService(db);
//svc.Configuration.EmailIsUsername = true;
var account = svc.GetByUsername(model.UserName);
if (account == null)
{
account = svc.CreateAccount(model.UserName, model.Password, model.UserName);
svc.AddClaim(account.ID, "name", model.LastName + " " + model.FirstName);
account.FirstName = model.FirstName;
account.LastName = model.LastName;
//account.Age = model.Age;
account.Organisation = model.Organisation;
account.Title = model.Title;
svc.Update(account);
}
}
//new CustomUserAccountService().CreateAccount("uname", "password", "*****@*****.**", dateCreated: DateTime.Now);
return Redirect("~/" + Constants.RoutePaths.Login + "?signin=" + signin);
}
return View();
}
public ConfigurationCheckerViewModel Check()
{
var model = new ConfigurationCheckerViewModel();
var owinStartup = System.Web.Configuration.WebConfigurationManager.AppSettings["owin:appStartup"];
if (owinStartup == "FortressOwinStartup")
{
model.OwinStartupIsSetup = true;
}
else
{
model.OwinStartupIsSetup = false;
if (owinStartup == "UmbracoDefaultOwinStartup")
{
model.OwinStartupIsFixable = true;
}
else
{
model.OwinStartupIsFixable = false;
}
}
//Confirm that the sms message template contains the {0} required for replacment
var settings = CustomDatabase.GetSettingsFromDatabase();
if (settings.SMS_MessageFormat.Contains("{0}"))
{
model.SmsMessageContainsReplacement = true;
}
else
{
model.SmsMessageContainsReplacement = false;
}
return(model);
}
static void testearBaseDeDatos()
{
string error = string.Empty;
CustomDatabase customDb = new CustomDatabase(
Config.dbServer, Config.dbName, Config.dbUser, Config.dbPassword);
if (customDb.open(ref error))
{
string sql = Persistence.DbPersistence.sqlInsertSource(1, "Servidor", "direccion_pelicula", "direccion_subtitulo", "descripcion pelicula", "HASDASDASDASDAS", DateTime.Now);
if (customDb.execute(sql, ref error))
{
Console.WriteLine("Ok");
}
}
customDb.close();
if (error.Length > 0)
{
Console.WriteLine(error);
}
}
public static void ConfigureUsers(IEnumerable<DefaultUser> users, string connString)
{
using (var db = new CustomDatabase(connString))
{
if (!db.Users.Any())
{
var repo = new CustomUserRepository(db);
var svc = new CustomUserAccountService(CustomConfig.Config, repo);
foreach (var u in users)
{
var account = svc.CreateAccount(u.UserName, u.Password, u.Email);
account.FirstName = u.FirstName;
account.LastName = u.LastName;
account.Age = u.Age;
svc.Update(account);
foreach (var role in u.Roles)
svc.AddClaim(account.ID, IdentityManager.Constants.ClaimTypes.Role, role);
}
db.SaveChanges();
}
}
}
public void Add_IsInvalid()
{
CustomDatabase db = new CustomDatabase(Element16);
Assert.That(() => db.Add(2), Throws.InvalidOperationException, "Database is full!");
}
private static CustomUserAccountService GetUserAccountService(CustomDatabase database)
{
var repo = new CustomUserAccountRepository(database);
var svc = new CustomUserAccountService(CustomConfig.Config, repo);
return svc;
}
public NavigationLinksBuilder(CustomDatabase db)
{
CurrentDB = db;
init();
}
static UserAccountService<CustomUser> GetUserAccountService(CustomDatabase db)
{
var repo = new CustomUserRepository(db);
UserAccountService<CustomUser> svc = new UserAccountService<CustomUser>(repo);
return svc;
}
public LectureTable(CustomDatabase database)
{
_database = database;
}
