public async Task <ActionResult> EnableGoogleAuthenticator(string provider, string returnUrl, bool rememberMe)
{
var CurrentUser = System.Web.HttpContext.Current.GetOwinContext().GetUserManager <ApplicationUserManager>().FindById(
System.Web.HttpContext.Current.User.Identity.GetUserId());
byte[] secretKey = KeyGeneration.GenerateRandomKey(20);
//string userName = User.Identity.GetUserName();
var userss = Session["userId"];
var userName = db.Users.Where(c => c.Id.Equals(userss.ToString())).Select(d => d.Email).First();
string sessionID = HttpContext.Session.SessionID;
string barcodeUrl = KeyUrl.GetTotpUrl(secretKey, userName) + "&issuer=MySuperApplication";
var secret = Base32Encoder.Encode(secretKey);
var barcode = HttpUtility.UrlEncode(barcodeUrl);
var ff = Base32Encoder.Encode(secretKey);
var model = new VerifyCodeViewModel
{
SecretKey = Base32Encoder.Encode(secretKey),
BarcodeUrl = HttpUtility.UrlEncode(barcodeUrl)
};
//ViewBag.Status = model;
return(View(new VerifyCodeViewModel {
Provider = provider, ReturnUrl = returnUrl, RememberMe = rememberMe, SecretKey = secret, BarcodeUrl = barcode
}));
//return View(model);
}
public async Task <bool> initializeEncryptionVariables()
{
string response = await new HttpRequester().RetrieveMessage("/connect");
JsonSerializerOptions serializerOptions = new JsonSerializerOptions();
serializerOptions.Converters.Add(new BigIntegerConverter());
InitialPackageContainer initialPackageContainer = JsonSerializer.Deserialize <InitialPackageContainer>(
response,
serializerOptions);
if (!Verifying.verifyMessage(
initialPackageContainer.signature, JsonSerializer.Serialize(
initialPackageContainer.initialPackage,
serializerOptions
),
initialPackageContainer.initialPackage.ServerPuk,
initialPackageContainer.initialPackage.EllipticCurve))
{
return(false);
}
ClientVariables.Puk = KeyGeneration.calculatePublicKey(
ClientVariables.Prk, initialPackageContainer.initialPackage.EllipticCurve);
ClientVariables.SharedKey = KeyGeneration.calculateMasterKey(
ClientVariables.Prk, initialPackageContainer.initialPackage.ServerPuk,
initialPackageContainer.initialPackage.EllipticCurve);
ClientVariables.EllipticCurve = initialPackageContainer.initialPackage.EllipticCurve;
ClientVariables.NiosKey = initialPackageContainer.initialPackage.NiosKey;
return(true);
}
// used after login is validated, no security in this other than simple sql illegals, validation should be implemented in controller
public async Task <string> SetLoginSessionIdAsync(User user, string tableName = UserTableName)
{
if (user == null)
{
return(null);
}
if (SqlSecurity.ContainsIllegals(user.UserId.ToString()))
{
return(null);
}
using (SqlConnection connection = GetConnection())
{
await connection.OpenAsync();
// Set user's session column to string sessionId and return so we can return Json
var _sessionId = KeyGeneration.GenerateSession();
user.LoginSession = _sessionId;
string sql = string.Format("UPDATE {0} SET {1} = '{2}' WHERE {3} = {4}", tableName, LoginSessKey, _sessionId, UserIdKey, user.UserId);
using (SqlCommand insertSession = new SqlCommand(sql, connection))
{
await insertSession.ExecuteNonQueryAsync();
return(_sessionId);
}
}
}
public bool ChangePassword(string userName, string oldPassword, string newPassword)
{
string oldPassEncrypt = KeyGeneration.EncryptString(INPUT_TEXT, oldPassword);
string newPassEncrypt = KeyGeneration.EncryptString(INPUT_TEXT, newPassword);
return(_nguyenHiepService.ChangePassword(userName, oldPassEncrypt, newPassEncrypt));
}
public static (MicroRatchetContext client, MicroRatchetContext server) CreateAndInitialize(int mtu = 80, int maximumBufferedPartialMessageSize = 50 * 1024)
{
var clientServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
var serverServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
var client = new MicroRatchetContext(clientServices, true);
var server = new MicroRatchetContext(serverServices, false);
var packet = client.InitiateInitialization();
while (!client.IsInitialized || !server.IsInitialized)
{
packet = server.Receive(packet).ToSendBack;
if (packet != null)
{
packet = client.Receive(packet).ToSendBack;
}
}
var cs = client.SaveStateAsByteArray();
var ss = server.SaveStateAsByteArray();
return(new MicroRatchetContext(clientServices, true, mtu, stateBytes: cs),
new MicroRatchetContext(serverServices, false, mtu, stateBytes: ss));
}
// GET: Auth
public ActionResult TwoStepVerif()
{
byte[] secretKey = KeyGeneration.GenerateRandomKey(20);
string userId = "dummy";
string qrcodeUrl = KeyUrl.GetTotpUrl(secretKey, userId) + "&issuer=MyOnlineMemo";
var encoder = new QRCodeEncoder();
encoder.QRCodeEncodeMode = QRCodeEncoder.ENCODE_MODE.BYTE;
encoder.QRCodeErrorCorrect = QRCodeEncoder.ERROR_CORRECTION.M;
var qrImage = encoder.Encode(qrcodeUrl);
string qrcodeString = "";
using (var ms = new MemoryStream())
{
qrImage.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
qrcodeString = Convert.ToBase64String(ms.GetBuffer());
}
//Test
Session["secretKey"] = Base32Encoder.Encode(secretKey);
// この認証キーをユーザーごとに保存しておく
ViewData["secretKey"] = Base32Encoder.Encode(secretKey);
ViewData["url"] = string.Format("data:{0};base64,{1}", "image/png", qrcodeString);
return(View());
}
public string GenerateSecretKey()
{
var key = KeyGeneration.GenerateRandomKey(_SecretKeyLength);
var base32String = Base32Encoding.ToString(key);
return(base32String.Replace("=", ""));
}
public async Task <ActionResult> Generate()
{
string input = null;
// If not data came in, then return
if (this.Request.Body == null)
{
return(StatusCode((int)HttpStatusCode.Conflict, new B2CResponseModel("Request content is null", HttpStatusCode.Conflict)));
}
// Read the input claims from the request body
using (StreamReader reader = new StreamReader(Request.Body, Encoding.UTF8))
{
input = await reader.ReadToEndAsync();
}
// Check input content value
if (string.IsNullOrEmpty(input))
{
return(StatusCode((int)HttpStatusCode.Conflict, new B2CResponseModel("Request content is empty", HttpStatusCode.Conflict)));
}
// Convert the input string into InputClaimsModel object
InputClaimsModel inputClaims = InputClaimsModel.Parse(input);
if (inputClaims == null)
{
return(StatusCode((int)HttpStatusCode.Conflict, new B2CResponseModel("Can not deserialize input claims", HttpStatusCode.Conflict)));
}
try
{
// Define the URL for the QR code. When user scan this URL, it opens one of the
// authentication apps running on the mobile device
byte[] secretKey = KeyGeneration.GenerateRandomKey(20);
string TOTPUrl = KeyUrl.GetTotpUrl(secretKey, $"{AppSettings.TOTPAccountPrefix}:{inputClaims.userName}",
AppSettings.TOTPTimestep);
TOTPUrl = $"{TOTPUrl}&issuer={AppSettings.TOTPIssuer.Replace(" ", "%20")}";
// Generate QR code for the above URL
var qrCodeGenerator = new QRCodeGenerator();
QRCodeData qrCodeData = qrCodeGenerator.CreateQrCode(TOTPUrl, QRCodeGenerator.ECCLevel.L);
BitmapByteQRCode qrCode = new BitmapByteQRCode(qrCodeData);
byte[] qrCodeBitmap = qrCode.GetGraphic(4);
B2CResponseModel output = new B2CResponseModel(string.Empty, HttpStatusCode.OK)
{
qrCodeBitmap = Convert.ToBase64String(qrCodeBitmap),
secretKey = this.EncryptAndBase64(Convert.ToBase64String(secretKey))
};
return(Ok(output));
}
catch (Exception ex)
{
return(StatusCode((int)HttpStatusCode.Conflict, new B2CResponseModel($"General error (REST API): {ex.Message}", HttpStatusCode.Conflict)));
}
}
/// <summary>
/// 随机生成google验证 base32密钥
/// </summary>
/// <param name="length">种子长度</param>
/// <returns></returns>
public string GoogleKeyForRand(int length = 10)
{
var keys = KeyGeneration.GenerateRandomKey(length);
var keystr = Base32Encoding.ToString(keys);
return(keystr);
}
public async Task <IActionResult> Auth([FromBody] User post)
{
User currentUserInDb;
// check if our user is in the database
if (string.IsNullOrEmpty(post.PhoneNumber) && string.IsNullOrEmpty(post.Email))
{
currentUserInDb = await sqlContext.GetUserByEmailAsync(post.Email);
}
else
{
currentUserInDb = await sqlContext.GetUserByPhoneAsync(post.PhoneNumber);
}
if (currentUserInDb == null)
{
return(Json(ErrorMessages.ContactMethodError()));
}
string token = post.Token;
// check if token is same as the one we sent them, if it is, proceed with login.
if (token == HttpContext.Session.GetString(TokenKey))
{
HttpContext.Session.Remove(TokenKey);
HttpContext.Session.Remove(PhoneKey);
string _sessionId = KeyGeneration.GenerateSession();
currentUserInDb.LoginSession = _sessionId;
await sqlContext.SetLoginSessionIdAsync(currentUserInDb);
return(Json(currentUserInDb));
}
return(Json(null));
}
public void InitialChainSymmetryTest1()
{
byte[] rk = rng.Generate(32);
byte[] rhk = rng.Generate(32);
byte[] shk = rng.Generate(32);
var skey1 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
var skey2 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
var ckey1 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
var ckey2 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
byte[] spub1 = skey1.GetPublicKey();
byte[] spub2 = skey2.GetPublicKey();
byte[] cpub1 = ckey1.GetPublicKey();
byte[] cpub2 = ckey2.GetPublicKey();
var secdhstep = EcdhRatchetStep.InitializeServer(kdf, digest,
skey1, rk, cpub1, skey2, rhk, shk);
var cecdhsteps = EcdhRatchetStep.InitializeClient(kdf, digest,
rk, spub1, spub2, ckey1, shk, rhk, ckey2);
// the initialized client can send to the server
var clientkeys = cecdhsteps[0].SendingChain.RatchetForSending(kdf);
var serverkeys = secdhstep.ReceivingChain.RatchetForReceiving(kdf, clientkeys.generation);
Assert.Equal(clientkeys.key, serverkeys.key);
}
public void SecondChainRatchetTest()
{
byte[] rk = rng.Generate(32);
byte[] rhk = rng.Generate(32);
byte[] shk = rng.Generate(32);
var skey1 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
var skey2 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
var skey3 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
var ckey1 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
var ckey2 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
var ckey3 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
byte[] spub1 = skey1.GetPublicKey();
byte[] spub2 = skey2.GetPublicKey();
byte[] spub3 = skey3.GetPublicKey();
byte[] cpub1 = ckey1.GetPublicKey();
byte[] cpub2 = ckey2.GetPublicKey();
byte[] cpub3 = ckey2.GetPublicKey();
var secdhstep1 = EcdhRatchetStep.InitializeServer(kdf, digest,
skey1, rk, cpub1, skey2, rhk, shk);
var cecdhsteps = EcdhRatchetStep.InitializeClient(kdf, digest,
rk, spub1, spub2, ckey1, shk, rhk, ckey2);
var secdhstep2 = secdhstep1.Ratchet(kdf, digest,
cpub2, skey3);
// and the server sends back
var cecdhstep3 = cecdhsteps[1].Ratchet(kdf, digest,
spub3, ckey3);
var serverkeys = secdhstep2.SendingChain.RatchetForSending(kdf);
var clientkeys = cecdhstep3.ReceivingChain.RatchetForReceiving(kdf, serverkeys.generation);
Assert.Equal(serverkeys.key, clientkeys.key);
}
public void ClientInitializationClientReinstantiation()
{
BouncyCastleServices clientServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
BouncyCastleServices serverServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
var client = new MicroRatchetContext(clientServices, true);
var clientInitPacket = client.InitiateInitialization();
var cs = client.SaveStateAsByteArray();
var server = new MicroRatchetContext(serverServices, false);
var responsePacket = server.Receive(clientInitPacket).ToSendBack;
var ss = server.SaveStateAsByteArray();
client = new MicroRatchetContext(clientServices, true, stateBytes: cs);
var firstPacket = client.Receive(responsePacket).ToSendBack;
cs = client.SaveStateAsByteArray();
server = new MicroRatchetContext(serverServices, false, stateBytes: ss);
var firstResponse = server.Receive(firstPacket).ToSendBack;
ss = server.SaveStateAsByteArray();
client = new MicroRatchetContext(clientServices, true, stateBytes: cs);
var lastResult = client.Receive(firstResponse).ToSendBack;
cs = client.SaveStateAsByteArray();
Assert.Null(lastResult);
}
public IdentityResult ResetAuthenticatorKeyAsync(ApplicationUser user)
{
try
{
var usertoken = Context.UserTokens.SingleOrDefault(ut => ut.UserId == user.Id);
if (usertoken != null)
{
Context.UserTokens.Remove(Context.UserTokens.SingleOrDefault(ut => ut.UserId == user.Id));
}
byte[] authenticatorKey = KeyGeneration.GenerateRandomKey(20);
var identityUserToken = new IdentityUserToken();
identityUserToken.UserId = user.Id;
identityUserToken.LoginProvider = "AspNetUserStore";
identityUserToken.Name = "AuthenticatorKey";
identityUserToken.Value = Base32Encoder.Encode(authenticatorKey);
Context.UserTokens.Add(identityUserToken);
Context.SaveChanges();
return(IdentityResult.Success);
}
catch (Exception exception)
{
return(new IdentityResult(exception.ToString()));
}
}
public static (string seed, byte[] seedBytes) CreateSeed()
{
// must be based in a HashMode or it may not work with all client libraries. Specially JS libs
var bytes = KeyGeneration.GenerateRandomKey(HASH_MODE);
return(Base32Encoding.ToString(bytes), bytes);
}
public async Task Handle_GivenCodeDoesVerify_ExpectSuccessfulResultAndEnrollAttempted()
{
var user = new Mock <IUser>();
user.Setup(x => x.AuthenticatorApps).Returns(() => new List <AuthenticatorApp>());
var userRepository = new Mock <IUserRepository>();
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.Setup(x => x.SaveEntitiesAsync(It.IsAny <CancellationToken>())).ReturnsAsync(() => true);
userRepository.Setup(x => x.UnitOfWork).Returns(unitOfWork.Object);
userRepository.Setup(x => x.Find(It.IsAny <Guid>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => Maybe.From(user.Object));
var clock = new Mock <IClock>();
var currentAuthenticatedUserProvider = new Mock <ICurrentAuthenticatedUserProvider>();
currentAuthenticatedUserProvider.Setup(x => x.CurrentAuthenticatedUser)
.Returns(Maybe.From(new AuthenticatedUser(TestVariables.UserId, "email-address", "first-name", "last-name") as ISystemUser));
var commandHandler = new EnrollAuthenticatorAppCommandHandler(userRepository.Object, clock.Object,
currentAuthenticatedUserProvider.Object);
var key = KeyGeneration.GenerateRandomKey();
var keyAsBase32String = Base32Encoding.ToString(key);
var totp = new Totp(key);
var code = totp.ComputeTotp();
var cmd = new EnrollAuthenticatorAppCommand(keyAsBase32String, code);
var result = await commandHandler.Handle(cmd, CancellationToken.None);
Assert.True(result.IsSuccess);
user.Verify(
x => x.EnrollAuthenticatorApp(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <DateTime>()),
Times.Once);
}
public async Task <IActionResult> SetupTotp()
{
ApplicationUser user = await _userManager.GetUserAsync(User);
if (!user.TotpEnabled)
{
byte[] keyBytes;
if (user.TotpSecret != null)
{
keyBytes = user.TotpSecret;
}
else
{
keyBytes = KeyGeneration.GenerateRandomKey(20);
}
string base32Key = Base32Encoding.ToString(keyBytes);
byte[] base32KeyBytes = Base32Encoding.ToBytes(base32Key);
Totp totp = new Totp(base32KeyBytes);
user.TotpSecret = keyBytes;
await _userManager.UpdateAsync(user);
QRCodeGenerator qrGenerator = new QRCodeGenerator();
QRCodeData qrCodeData = qrGenerator.CreateQrCode($"otpauth://totp/SPSAuthChallenge:{user.UserName}?secret={base32Key}&issuer=SPSAuthChallenge", QRCodeGenerator.ECCLevel.Q);
Base64QRCode qrCode = new Base64QRCode(qrCodeData);
string qrCodeBase64 = qrCode.GetGraphic(10);
SetupTotpViewModel model = new SetupTotpViewModel
{
QRCodeBase64 = qrCodeBase64
};
return(View(model));
}
return(RedirectToAction(nameof(Index)));
}
public async Task Handle_GivenSavingFails_ExpectFailedResult()
{
var user = new Mock <IUser>();
user.Setup(x => x.AuthenticatorApps).Returns(() => new List <AuthenticatorApp>());
var userRepository = new Mock <IUserRepository>();
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.Setup(x => x.SaveEntitiesAsync(It.IsAny <CancellationToken>())).ReturnsAsync(() => false);
userRepository.Setup(x => x.UnitOfWork).Returns(unitOfWork.Object);
userRepository.Setup(x => x.Find(It.IsAny <Guid>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => Maybe.From(user.Object));
var clock = new Mock <IClock>();
var currentAuthenticatedUserProvider = new Mock <ICurrentAuthenticatedUserProvider>();
currentAuthenticatedUserProvider.Setup(x => x.CurrentAuthenticatedUser)
.Returns(Maybe.From(new AuthenticatedUser(TestVariables.UserId, "email-address", "first-name", "last-name") as ISystemUser));
var commandHandler = new EnrollAuthenticatorAppCommandHandler(userRepository.Object, clock.Object,
currentAuthenticatedUserProvider.Object);
var key = KeyGeneration.GenerateRandomKey();
var keyAsBase32String = Base32Encoding.ToString(key);
var totp = new Totp(key);
var code = totp.ComputeTotp();
var cmd = new EnrollAuthenticatorAppCommand(keyAsBase32String, code);
var result = await commandHandler.Handle(cmd, CancellationToken.None);
Assert.True(result.IsFailure);
Assert.Equal(ErrorCodes.SavingChanges, result.Error.Code);
}
public void InitialChainRatchetTest()
{
byte[] rk = rng.Generate(32);
byte[] rhk = rng.Generate(32);
byte[] shk = rng.Generate(32);
var skey1 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
var skey2 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
var skey3 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
var ckey1 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
var ckey2 = new KeyAgreement(KeyGeneration.GeneratePrivateKey());
byte[] spub1 = skey1.GetPublicKey();
byte[] spub2 = skey2.GetPublicKey();
byte[] spub3 = skey3.GetPublicKey();
byte[] cpub1 = ckey1.GetPublicKey();
byte[] cpub2 = ckey2.GetPublicKey();
var secdhstep1 = EcdhRatchetStep.InitializeServer(kdf, digest,
skey1, rk, cpub1, skey2, rhk, shk);
var cecdhsteps = EcdhRatchetStep.InitializeClient(kdf, digest,
rk, spub1, spub2, ckey1, shk, rhk, ckey2);
// client sends new ECDH to server
var secdhstep2 = secdhstep1.Ratchet(kdf, digest,
cpub2, skey3);
// which means the client now can send using its latest step
var clientkeys = cecdhsteps[1].SendingChain.RatchetForSending(kdf);
var serverkeys = secdhstep2.ReceivingChain.RatchetForReceiving(kdf, clientkeys.generation);
Assert.Equal(clientkeys.key, serverkeys.key);
}
private void generateMoreKeysToolStripMenuItem_Click(object sender, EventArgs e)
{
KeyGeneration kg = new KeyGeneration();
kg.ShowDialog();
kg.Dispose(); // Once window closes we'll release resources
}
public async Task <IActionResult> GoogleTokenAsync(string code, string provider, bool rememberMe, string returnUrl = null)
{
// Require that the user has already logged in via username/password or external login
var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
if (user == null)
{
return(View("Error"));
}
string message = "Verificación de 2 pasos con Google Authorization";
byte[] secretKey = KeyGeneration.GenerateRandomKey(20);
string userId = user.Id;
string barcodeUrl = KeyUrl.GetTotpUrl(secretKey, userId) + "&issuer=AjeGroupCore";
var model = new GoogleAuthenticatorViewModel
{
SecretKey = Convert.ToBase64String(secretKey),
BarcodeUrl = WebUtility.UrlEncode(barcodeUrl),
Provider = provider,
RememberMe = rememberMe,
ReturnUrl = returnUrl,
Code = code
};
ViewData["Message"] = message;
return(View(model));
}
public async Task GetTwoFactorAsync(User user, Enums.TwoFactorProvider provider)
{
if (user.TwoFactorEnabled && user.TwoFactorProvider.HasValue && user.TwoFactorProvider.Value == provider)
{
switch (provider)
{
case Enums.TwoFactorProvider.Authenticator:
if (!string.IsNullOrWhiteSpace(user.AuthenticatorKey))
{
return;
}
break;
default:
throw new ArgumentException(nameof(provider));
}
}
user.TwoFactorProvider = provider;
// Reset authenticator key.
user.AuthenticatorKey = null;
switch (provider)
{
case Enums.TwoFactorProvider.Authenticator:
var key = KeyGeneration.GenerateRandomKey(20);
user.AuthenticatorKey = Base32Encoder.Encode(key);
break;
default:
throw new ArgumentException(nameof(provider));
}
await SaveUserAsync(user);
}
public async Task <IActionResult> Configuration()
{
if (!Request.Form.ContainsKey("Email"))
{
return(Unauthorized());
}
var email = Request.Form
.Where(x => x.Key == "Email")
.Select(x => x.Value)
.FirstOrDefault()
.ToString()
.Clean();
if (string.IsNullOrEmpty(email))
{
return(Unauthorized());
}
var user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
return(Unauthorized());
}
// check for existing token
var existingToken = user.Tokens.Where(x => x.LoginProvider == "Two-Factor").FirstOrDefault();
if (existingToken != null)
{
user.Tokens.Remove(existingToken);
}
// generate new token
var secret = Base32Encoding.ToString(KeyGeneration.GenerateRandomKey(20));
user.TwoFactorEnabled = true;
user.Tokens.Add(new IdentityUserToken <string>()
{
LoginProvider = "Two-Factor",
Name = user.Email,
UserId = user.Id,
Value = secret
});
var identityResult = await _userManager.UpdateAsync(user);
if (!identityResult.Succeeded)
{
_logger.Exception(new Exception(identityResult.Errors.First().Description));
return(BadRequest(identityResult.Errors.First().Description));
}
ViewData["Email"] = user.Email;
ViewData["Token"] = secret;
ViewData["LoginUrl"] = _appSettings.Application.MainSiteUrlTrim + "/Account/Login";
return(View());
}
public void EncodePublicKeyTest()
{
var publicKey = Sodium.Utilities.HexToBinary("34f066fa6957e569848e7d6d1faaa129fe43e7bb6b4047e1db34d4e09a9f4e51");
const string EXPECTED = "Lqm2Foa9keELvGf8cYHJB3CRzEgPLuxJnBdtbZRbhuGmx3dhQB";
var actual = KeyGeneration.EncodePublicKey(publicKey);
Assert.AreEqual(EXPECTED, actual);
}
public MainWindow()
{
InitializeComponent();
Label.Focus();
Label.Text = "one";
Issuer.Text = "two";
Secret.Text = Base32Encoding.ToString(KeyGeneration.GenerateRandomKey(20));
}
public void DisposeTest()
{
byte[] priKey = KeyGeneration.GeneratePrivateKey();
var ke = new KeyAgreement(priKey);
ke.Dispose();
Assert.Throws <ObjectDisposedException>(() => ke.GetPublicKey());
Assert.Throws <ObjectDisposedException>(() => ke.DeriveKey(new byte[0]));
}
public Task <Result <InitiateAuthenticatorAppEnrollmentCommandResult, ErrorData> > Handle(
InitiateAuthenticatorAppEnrollmentCommand request, CancellationToken cancellationToken)
{
var key = KeyGeneration.GenerateRandomKey();
var keyAsBase32String = Base32Encoding.ToString(key);
return(Task.FromResult(Result.Ok <InitiateAuthenticatorAppEnrollmentCommandResult, ErrorData>(
new InitiateAuthenticatorAppEnrollmentCommandResult(keyAsBase32String))));
}
public void SignatureTest()
{
var key = KeyGeneration.GeneratePrivateKey();
var digest = new RandomNumberGenerator().Generate(32);
Signature sig = new Signature(key);
var signature = sig.Sign(digest);
Assert.NotNull(signature);
Assert.Equal(64, signature.Length);
}
private void _CompleteProcessing(KeyPair key)
{
if (key != null)
{
Common.KeyPair = key;
Common.Id = KeyGeneration.EncodePublicKey(key.PublicKey);
Invoke(Complete, this, EventArgs.Empty);
}
}
public Task <string> GenerateAsync(string purpose, UserManager <UserInfo> manager, UserInfo user)
{
if (string.IsNullOrEmpty(user.DualAuthenticationSecretKey))
{
var key = KeyGeneration.GenerateRandomKey(10);
var base32String = Base32Encoding.ToString(key);
user.DualAuthenticationSecretKey = base32String;
}
return(Task.FromResult(user.DualAuthenticationSecretKey));
}
private void SetGenerateKeyDelegate()
{
GenerateKey = delegate(ComparingValues valuesToCompare)
{
int[] valuesToSort = new int[positions.Count];
for (int i = 0; i < valuesToSort.Length; ++i)
{
valuesToSort[i] = i;
}
Comparison<int> sortByValue = delegate(int a, int b)
{
Record person1 = new Record(path, positions[a]);
Record person2 = new Record(path, positions[b]);
if (valuesToCompare == ComparingValues.name)
{
return person1.name.CompareTo(person2.name);
}
else if (valuesToCompare == ComparingValues.surname)
{
return person1.surname.CompareTo(person2.surname);
}
else
return person1.id.CompareTo(person2.id);
};
Array.Sort(valuesToSort, sortByValue);
if (valuesToCompare == ComparingValues.name)
{
sortedNames = valuesToSort;
}
else if (valuesToCompare == ComparingValues.surname)
{
sortedSurnames = valuesToSort;
}
else
sortedIDs = valuesToSort;
};
}
