protected void btnValidate_Click(object sender, EventArgs e)
{
String PinCode = this.txtCode.Text.Trim();
if (!String.IsNullOrEmpty(PinCode))
{
var result = TwoFactor.ValidatePIN(TwoFactorCode, PinCode);
if (result)
{
this.lblValidationResult.Text = PinCode + " is not a valid 3FA code at time " + xUserTime.LocalTime();
this.lblValidationResult.ForeColor = System.Drawing.Color.Green;
if (TwoFactorUserItem != null && TwoFactorUserItem.UserID > 0)
{
//User Login
UserController.UserLogin(PortalId, TwoFactorUserItem, PortalSettings.PortalName, WebHelper.UserHost, false);
//Redirect return url or index url
try { Response.Redirect(GetRedirectUrl()); }
finally { }
}
}
else
{
this.lblValidationResult.Text = PinCode + " is not a valid 3FA code at time " + xUserTime.LocalTime();
this.lblValidationResult.ForeColor = System.Drawing.Color.Red;
}
}
else
{
this.lblValidationResult.Text = "Please enter 3FA code.";
this.lblValidationResult.ForeColor = System.Drawing.Color.Red;
}
}
public bool ValidateAndSaveGoogleAuth(string code)
{
var database = DatabaseContext.Database;
var user = Security.CurrentUser;
try
{
var twoFactorAuthenticator = new TwoFactorAuthenticator();
var all = database.Fetch <TwoFactor>("WHERE userId = @userId",
new { userId = user.Id });
var result = all.LastOrDefault(t => t.Key == Constants.GoogleAuthenticatorProviderName);
if (result != null)
{
var isValid = twoFactorAuthenticator.ValidateTwoFactorPIN(result.Value, code);
if (isValid == false)
{
return(false);
}
var tf = new TwoFactor {
Confirmed = true, Value = result.Value, UserId = user.Id, Key = Constants.GoogleAuthenticatorProviderName
};
var update = database.Update(tf);
isValid = update > 0;
return(isValid);
}
}
catch (Exception ex)
{
LogHelper.Error <TwoFactorAuthController>("Could not log in with the provided one-time-password", ex);
}
return(false);
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
if (!IsPostBack)
{
if (!(Request.UrlReferrer != null && !String.IsNullOrEmpty(Request.UrlReferrer.ToString())))
{
Response.Redirect(Globals.LoginURL(UrlReturn, false));
}
else if (TwoFactorUserItem.LastModifiedOnDate.Ticks != TwoFactorUserTicks)
{
Response.Redirect(Request.RawUrl);
}
//Generate Random Secret Key
hfSecretKey.Value = Guid.NewGuid().ToString().Replace("-", "").Substring(0, 10);
//
var setupInfo = TwoFactor.GenerateSetupCode("Google Two Factor", TwoFactorUserItem.Username, hfSecretKey.Value, 150, 150);
string qrCodeImageUrl = setupInfo.QrCodeSetupImageUrl;
string manualEntrySetupCode = setupInfo.ManualEntryKey;
this.imgQrCode.ImageUrl = qrCodeImageUrl;
this.lblManualSetupCode.Text = manualEntrySetupCode;
}
}
catch (Exception ex)
{
DotNetNuke.Services.Exceptions.Exceptions.ProcessModuleLoadException(this, ex);
}
}
public static bool Validate(string code, string token, DateTime now)
{
TwoFactor generator = new TwoFactor(GetSecret(token));
//generator.GenerateCode(now);
return(generator.ValidateCode(code, now.ToUniversalTime()));
}
public void TestMethod1()
{
string secret = TwoFactor.GenerateRandomSecret();
var twoFactor = new TwoFactor(secret);
string x = twoFactor.GenerateCode();
Assert.AreEqual(x.Length, 6);
Assert.IsTrue(twoFactor.ValidateCode(x) && !twoFactor.ValidateCode("000000"));
}
public TwoFactorAuthInfo GoogleAuthenticatorSetupCode()
{
var tfa = new TwoFactorAuthenticator();
var user = Security.CurrentUser;
var accountSecretKey = Guid.NewGuid().ToString();
var setupInfo = tfa.GenerateSetupCode(Constants.ApplicationName, user.Email, accountSecretKey, 300, 300);
var database = DatabaseContext.Database;
var twoFactorAuthInfo = new TwoFactorAuthInfo();
var existingAccount = database.Fetch <TwoFactor>(string.Format("WHERE userId = {0} AND [key] = '{1}'",
user.Id, Constants.GoogleAuthenticatorProviderName));
if (existingAccount.Any())
{
var account = existingAccount.First();
if (account.Confirmed)
{
return(twoFactorAuthInfo);
}
var tf = new TwoFactor {
Value = accountSecretKey, UserId = user.Id, Key = Constants.GoogleAuthenticatorProviderName
};
var update = database.Update(tf);
if (update == 0)
{
return(twoFactorAuthInfo);
}
}
else
{
var result = database.Insert(new TwoFactor {
UserId = user.Id, Key = Constants.GoogleAuthenticatorProviderName, Value = accountSecretKey, Confirmed = false
});
if (result is bool == false)
{
return(twoFactorAuthInfo);
}
var insertSucces = (bool)result;
if (insertSucces == false)
{
return(twoFactorAuthInfo);
}
}
twoFactorAuthInfo.Secret = setupInfo.ManualEntryKey;
twoFactorAuthInfo.Email = user.Email;
twoFactorAuthInfo.ApplicationName = Constants.ApplicationName;
return(twoFactorAuthInfo);
}
public async Task <ActionResult> TwoFactor(TwoFactor two)
{
var signInStatus = await SignInManager.TwoFactorSignInAsync(two.Provider, two.Code, true, two.RememberBrowser);
switch (signInStatus)
{
case SignInStatus.Success:
return(RedirectToAction("Index", "Home"));
default:
ModelState.AddModelError("", "Invalid Crendentials");
return(View(two));
}
}
public async Task <TwoFactor> GetToken(string SecretToken)
{
TwoFactor twoFactor = new TwoFactor();
try
{
var content = await _Client.GetStringAsync(url + SecretToken);
twoFactor = JsonConvert.DeserializeObject <TwoFactor>(content);
}
catch (Exception e)
{
twoFactor.LoginToken = "Your Secret token " + SecretToken + " is not valid";
}
return(twoFactor);
}
private async void Init()
{
twoFactor = await tokenService.GetToken(SecretToken);
if (twoFactor.LoginToken != "Your Secret token " + SecretToken + " is not valid")
{
Enabled = false;
Token = "Your Token is: " + twoFactor.LoginToken;
_timer = new Timer(TimeSpan.FromSeconds(1), CountDown);
TotalSeconds = _totalSeconds;
_timer.Start();
}
else
{
Token = twoFactor.LoginToken;
}
}
public async Task <IActionResult> LoginTwoStep(TwoFactor twoFactor, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(twoFactor.TwoFactorCode));
}
var result = await signInManager.TwoFactorSignInAsync("Email", twoFactor.TwoFactorCode, false, false);
if (result.Succeeded)
{
return(Redirect(returnUrl ?? "/"));
}
else
{
ModelState.AddModelError("", "Invalid Login Attempt");
return(View());
}
}
public async Task <IActionResult> LoginTwoStep(TwoFactor twoFactor, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(twoFactor.TwoFactorCode));
}
var result = await signInManager.TwoFactorSignInAsync("Email", twoFactor.TwoFactorCode, false, false);
if (result.Succeeded)
{
return(Redirect(returnUrl ?? "/"));
}
else
{
_toastNotification.AddErrorToastMessage(ResponseMessageUtilities.Invalid_Login_Attempt);
return(View());
}
}
/// <summary>
/// Generate a 2FA secret
/// </summary>
/// <param name="token">The user's token</param>
/// <returns>the secret or null</returns>
public static Account GenerateSecretForAccount(string token)
{
try
{
string secret = TwoFactor.GenerateSecret();
using (var context = new OverstagContext())
{
var a = context.Accounts.First(f => f.Token == token);
a.TwoFactor = secret;
a.TwoFactorCodes = string.Join(',', TFA.GenerateBackupCodes());
context.Accounts.Update(a);
context.SaveChanges();
return(a);
}
}
catch
{
return(null);
}
}
public async Task <IActionResult> LoginTwoStep(TwoFactor twoFactor, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(twoFactor.TwoFactorCode));
}
var myuser = await userManager.FindByEmailAsync(twoFactor.Email);
var result = await userManager.ChangePhoneNumberAsync(myuser, myuser.PhoneNumber, twoFactor.TwoFactorCode);
if (result.Succeeded)
{
if (myuser != null)
{
await signInManager.SignInAsync(myuser, isPersistent : false);
}
return(RedirectToAction("Index", "Products"));
}
ModelState.AddModelError("", "Invalid Login Attempt");
return(View());
}
public async Task <IActionResult> TwoFactor(TwoFactor model)
{
var result = await HttpContext.AuthenticateAsync(IdentityConstants.TwoFactorUserIdScheme);
if (!result.Succeeded)
{
ModelState.AddModelError("", "O seu Token expirou!");
return(View());
}
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(result.Principal.FindFirstValue("sub"));
if (user != null)
{
var isValid = await _userManager.VerifyTwoFactorTokenAsync(user, result.Principal.FindFirstValue("amr"), model.Token);
if (isValid == true)
{
await HttpContext.SignOutAsync(IdentityConstants.TwoFactorUserIdScheme);
var claimsPrincipal = await _userClaimsPrincipalFactory.CreateAsync(user);
await HttpContext.SignInAsync(IdentityConstants.ApplicationScheme, claimsPrincipal);
return(RedirectToAction("About"));
}
ModelState.AddModelError("", "Token inválido!");
return(View());
}
ModelState.AddModelError("", "Requisição inválida!");
}
return(View());
}
public bool ValidateAndSaveGoogleAuth(string code, int userId)
{
using (var scope = scopeProvider.CreateScope(autoComplete: true))
{
try
{
var twoFactorAuthenticator = new TwoFactorAuthenticator();
var all = scope.Database.Fetch <TwoFactor>("WHERE userId = @userId",
new { userId = userId });
var result = all.LastOrDefault(t => t.Key == Constants.GoogleAuthenticatorProviderName);
if (result != null)
{
var isValid = twoFactorAuthenticator.ValidateTwoFactorPIN(result.Value, code);
if (isValid == false)
{
return(false);
}
var tf = new TwoFactor
{
Confirmed = true, Value = result.Value, UserId = userId,
Key = Constants.GoogleAuthenticatorProviderName
};
var update = scope.Database.Update(tf);
isValid = update > 0;
return(isValid);
}
}
catch (Exception ex)
{
Current.Logger.Error(typeof(TwoFactorService), ex);
}
return(false);
}
}
public HttpResponseMessage GetToken(string token)
{
TwoFactorService.TwoFactor_Service service = new TwoFactorService.TwoFactor_Service();
service.Url = @"http://*****:*****@"DESKTOP-AOPOAEF\DENNIS", "070886Denz");
//service.UseDefaultCredentials = true;
service.Credentials = networkCredential;
List <TwoFactorService.TwoFactor_Filter> filterArray = new List <TwoFactorService.TwoFactor_Filter>();
TwoFactorService.TwoFactor_Filter tokenFilter = new TwoFactorService.TwoFactor_Filter();
tokenFilter.Field = TwoFactorService.TwoFactor_Fields.Secret_Token;
tokenFilter.Criteria = token;
filterArray.Add(tokenFilter);
TwoFactorService.TwoFactor[] list = service.ReadMultiple(filterArray.ToArray(), null, 1);
if (list.Count() == 0)
{
HttpResponseMessage response2 = Request.CreateResponse(HttpStatusCode.NotFound);
return(response2);
}
TwoFactor twoFactor = new TwoFactor();
Random random = new Random();
int tempToken = random.Next(10000, 88888) + DateTime.Now.Second;
string secretToken = tempToken.ToString();
list[0].Login_Token = secretToken;
service.Update(ref list[0]);
twoFactor.UserName = list[0].User_ID;
twoFactor.SecretToken = list[0].Secret_Token;
twoFactor.LoginToken = list[0].Login_Token;
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK);
response.Content = new StringContent(JsonConvert.SerializeObject(twoFactor), Encoding.UTF8, "application/json");
return(response);
}
public TwoFactorAuthInfo GetExistingAccount(int userId, string googleAuthenticatorProviderName, string accountSecretKey)
{
var twoFactorAuthInfo = new TwoFactorAuthInfo();
using (var scope = scopeProvider.CreateScope(autoComplete: true))
{
try
{
var existingAccount = scope.Database.Fetch <TwoFactor>(string.Format("WHERE userId = {0} AND [key] = '{1}'",
userId, Constants.GoogleAuthenticatorProviderName));
if (existingAccount.Any())
{
var account = existingAccount.First();
if (account.Confirmed)
{
return(twoFactorAuthInfo);
}
var tf = new TwoFactor {
Value = accountSecretKey, UserId = userId, Key = Constants.GoogleAuthenticatorProviderName
};
var update = scope.Database.Update(tf);
if (update == 0)
{
return(twoFactorAuthInfo);
}
}
else
{
var result = scope.Database.Insert(new TwoFactor {
UserId = userId, Key = Constants.GoogleAuthenticatorProviderName, Value = accountSecretKey, Confirmed = false
});
if (result is bool == false)
{
return(twoFactorAuthInfo);
}
var insertSucces = (bool)result;
if (insertSucces == false)
{
return(twoFactorAuthInfo);
}
}
}
catch (Exception e)
{
var result = scope.Database.Insert(new TwoFactor {
UserId = userId, Key = Constants.GoogleAuthenticatorProviderName, Value = accountSecretKey, Confirmed = false
});
if (result is bool == false)
{
return(twoFactorAuthInfo);
}
var insertSucces = (bool)result;
if (insertSucces == false)
{
return(twoFactorAuthInfo);
}
//throw;
}
return(twoFactorAuthInfo);
}
}
/// <summary> /// Generates a new 2fa secret /// </summary> /// <returns>A new secret</returns> public static string GenerateSecret() => TwoFactor.GenerateSecret();
