public async Task <AppUser> CreateUser(RegisterDto registerDto) { if (await UserExists(registerDto.Username)) { return(null); } using var hmac = new HMACSHA512(); //will provide hashing algorithm var user = new AppUser { Username = registerDto.Username.ToLower(), PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registerDto.Password)), PasswordSalt = hmac.Key, Organisation = await _dataContext.Organisations.FindAsync(registerDto.OrganisationId), Type = await _dataContext.UserTypes.FindAsync(registerDto.UserTypeId), Firstname = registerDto.Firstname, Lastname = registerDto.Lastname }; _dataContext.Users.Add(user); await _dataContext.SaveChangesAsync(); return(user); }
/// <summary> /// HmacSha512 加密 /// </summary> /// <param name="clearMessage"></param> /// <param name="secretKeyString"></param> /// <returns></returns> protected string HmacSha512(string clearMessage, string secretKeyString) { Encoding encoder = Encoding.UTF8; //Transform the clear query string to a byte array byte[] messageBytes = encoder.GetBytes(clearMessage); //Transform the secret key string to a byte array var key = Convert.ToBase64String(encoder.GetBytes(secretKeyString)); byte[] secretKeyBytes = encoder.GetBytes(key); //Init the Hmac SHA512 generator with the key HMACSHA512 hmacsha512 = new HMACSHA512(secretKeyBytes); //Hash the message byte[] hashValue = hmacsha512.ComputeHash(messageBytes); //Transform the hash bytes array to a string string string hmac = BitConverter.ToString(hashValue).Replace("-", ""); //Force the case of the HMAC key to Uppercase return(hmac); }
private static bool VerifyPasswordHash(string password, byte[] storedHash, byte[] storedSalt) { if (password == null) { throw new ArgumentNullException("password"); } if (string.IsNullOrWhiteSpace(password)) { throw new ArgumentException("Value cannot be empty or whitespace only string.", "password"); } if (storedHash.Length != 64) { throw new ArgumentException("Invalid length of password hash (64 bytes expected).", "passwordHash"); } if (storedSalt.Length != 128) { throw new ArgumentException("Invalid length of password salt (128 bytes expected).", "passwordHash"); } using (var hmac = new HMACSHA512(storedSalt)) { var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(password)); for (int i = 0; i < computedHash.Length; i++) { if (computedHash[i] != storedHash[i]) { return(false); } } } return(true); }
private string InternalQuery(NameValueDictionary args) { lock (m_nonceLock) { args.Add("nonce", GetNonce().ToString(CultureInfo.InvariantCulture)); var dataStr = BuildPostData(args); var data = Encoding.ASCII.GetBytes(dataStr); using (var httpContent = new FormUrlEncodedContent(args)) { using (var request = new HttpRequestMessage(HttpMethod.Post, WebApi.RootUrl + "/tapi")) { request.Headers.Add("Key", m_key); request.Headers.Add("Sign", ByteArrayToString(m_hashMaker.ComputeHash(data)).ToLowerInvariant()); request.Content = httpContent; var response = WebApi.Client.SendAsync(request).Result; var resultString = response.Content.ReadAsStringAsync().Result; return(resultString); } } } }
private static string GetEncodedPassword(string password, string passwordSalt) { var encoder = new ASCIIEncoding(); var messageBytes = encoder.GetBytes(password); var secretKeyBytes = new byte[passwordSalt.Length / 2]; for (int index = 0; index < secretKeyBytes.Length; index++) { string byteValue = passwordSalt.Substring(index * 2, 2); secretKeyBytes[index] = byte.Parse(byteValue, NumberStyles.HexNumber, CultureInfo.InvariantCulture); } var hmacsha512 = new HMACSHA512(secretKeyBytes); byte[] hashValue = hmacsha512.ComputeHash(messageBytes); string hmac = ""; foreach (byte x in hashValue) { hmac += String.Format("{0:x2}", x); } return(hmac.ToUpper()); }
public async Task <ActionResult <UserResponse> > Login(LoginUserRequest request) { var user = await _context.Users.SingleOrDefaultAsync(u => u.UserName == request.UserName.ToLower()); if (user == null) { return(Unauthorized("Invalid username or password")); } using var hmac = new HMACSHA512(user.PasswordSalt); var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(request.Password)); if (!computedHash.SequenceEqual(user.PasswordHash)) { return(Unauthorized("Invalid username or password")); } return(new UserResponse { UserName = user.UserName, Token = _tokenService.CreateToken(user) }); }
public static Uri GetHmacedUri(string uri, string key, string[] paramsToVerify) { UriBuilder result = new UriBuilder(uri); NameValueCollection param = HttpUtility.ParseQueryString(result.Query); NameValueCollection verifiedParams = HttpUtility.ParseQueryString(string.Empty); foreach (string str in paramsToVerify) { verifiedParams[str] = HttpUtility.UrlEncode(param[str]); } string pathAndQuery = result.Path + "?" + verifiedParams.ToString(); System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[] keyByte = encoding.GetBytes(key); HMACSHA512 hmacsha512 = new HMACSHA512(keyByte); byte[] computeHash = hmacsha512.ComputeHash(encoding.GetBytes(pathAndQuery)); string hash = BitConverter.ToString(computeHash).Replace("-", string.Empty).ToLower(); verifiedParams["hmac"] = hash; result.Query = verifiedParams.ToString(); return(result.Uri); }
public static bool VerifyPasswordHash(string password, byte[] storedHash, byte[] storedSalt) { if (storedHash.Length != 64) { throw new AppException("Invalid length of password hash (64 bytes expected)."); } if (storedSalt.Length != 128) { throw new AppException("Invalid length of password salt (128 bytes expected)."); } using (var hmac = new HMACSHA512(storedSalt)) { var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(password)); for (int i = 0; i < computedHash.Length; i++) { if (computedHash[i] != storedHash[i]) { return(false); } } } return(true); }
public async Task <ActionResult <AppUser> > Login(LoginDto loginDto) { var user = await _context.Users .SingleOrDefaultAsync(x => x.UserName == loginDto.Username); if (user == null) { return(Unauthorized("Invalid username")); } using var hmac = new HMACSHA512(user.PasswordSalt); var ComputeHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(loginDto.password)); for (int i = 0; i < ComputeHash.Length; i++) { if (ComputeHash[i] != user.PasswordHash[i]) { return(Unauthorized("Invalid password")); } } return(user); }
public async Task <ActionResult <UserDto> > Register(RegisterDto registerDto) { if (await UserExists(registerDto.Username)) { return(BadRequest("User nam is taken")); } using var hmac = new HMACSHA512(); var user = new AppUser { UserName = registerDto.Username.ToLower(), passwordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registerDto.Password)), passwordSlat = hmac.Key }; _context.Users.Add(user); await _context.SaveChangesAsync(); return(new UserDto { Username = user.UserName, Token = _tokenService.CreateToken(user) }); }
public async Task <ActionResult <AppUser> > Login(LoginDTO loginDTo) { AppUser user = await __context.MyProperty.SingleOrDefaultAsync(x => x.UserName == loginDTo.Username.ToLower()); if (user == null) { return(Unauthorized("invalid username")); } using HMAC hMAC = new HMACSHA512(user.PasswordSalt); var Computedpassword = hMAC.ComputeHash(Encoding.UTF8.GetBytes(loginDTo.Password)); for (int i = 0; i < Computedpassword.Length; i++) { if (Computedpassword[i] != user.PasswordHash[i]) { return(Unauthorized("Wrong password")); } } return(user); }
new public static decimal sGetLucky(string server, string client, int nonce) { HMACSHA512 betgenerator = new HMACSHA512(); List <byte> serverb = new List <byte>(); for (int i = 0; i < server.Length; i++) { serverb.Add(Convert.ToByte(server[i])); } List <byte> buffer = new List <byte>(); string msg = client; foreach (char c in msg) { buffer.Add(Convert.ToByte(c)); } betgenerator.Key = buffer.ToArray(); byte[] hash = betgenerator.ComputeHash(serverb.ToArray()); StringBuilder hex = new StringBuilder(hash.Length * 2); foreach (byte b in hash) { hex.AppendFormat("{0:x2}", b); } string hashres = hex.ToString(); int start = (hashres.ToString().Length / 2) - 4; string s = hashres.ToString().Substring(start, 8); UInt32 seed = UInt32.Parse(s, System.Globalization.NumberStyles.HexNumber); MersenneTwister twist = new MersenneTwister(seed); int t4 = (int)(twist.genrand_real2() * 100); return(t4); }
public async Task <ActionResult <UserDto> > Register(RegisterDto registerDto) { if (await UserExists(registerDto.Username.ToLower())) { return(BadRequest("User Name is taken!")); } var user = _maper.Map <AppUser>(registerDto); using var hmac = new HMACSHA512(); user.UserName = registerDto.Username.ToLower(); user.PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registerDto.Password)); user.PasswordSalt = hmac.Key; _context.Users.Add(user); await _context.SaveChangesAsync(); return(new UserDto { Username = user.UserName, Token = _tokenService.CreateToken(user), KnownAs = user.KnownAs }); }
public async Task<ActionResult<UserDto>> Register(RegisterDto registerDto) // public async Task<ActionResult<AppUser>> Register(string username, string password) { if (await UserExists(registerDto.Username)) return BadRequest ("Username is Taken"); using var hmac = new HMACSHA512(); //metode hashing var user = new AppUser { Username = registerDto.Username.ToLower(), PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registerDto.Password)), PasswordSalt = hmac.Key }; _context.Users.Add(user); await _context.SaveChangesAsync(); //save PasswordHash, PasswordSalt dan username // return user; return new UserDto { Username = user.Username, Token = _tokenService.CreateToken(user) }; }
public string post(String url, String parameters, String key, String secret) { try { // lock (objLock) { Int32 unixTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds; parameters = "?nonce=" + unixTimestamp + "&" + parameters; Logger.log(url + parameters); var request = (HttpWebRequest)WebRequest.Create(url + parameters); ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; var data = Encoding.ASCII.GetBytes(url + parameters); HMACSHA512 encryptor = new HMACSHA512(); encryptor.Key = Encoding.ASCII.GetBytes(secret); String sign = Utils.ByteToString(encryptor.ComputeHash(data)).ToLower(); request.Headers["apisign"] = sign; request.Method = "POST"; var response = (HttpWebResponse)request.GetResponse(); String result = new StreamReader(response.GetResponseStream()).ReadToEnd(); Logger.log(result); return(result); } } catch (Exception ex) { Logger.log("ERROR POST " + ex.Message + ex.StackTrace); return(null); } finally { } }
public static async Task SeedUser(DataContext context) { if (await context.Users.AnyAsync()) { return; } var userData = await System.IO.File.ReadAllTextAsync("Data/UserSeedData.json"); var users = JsonConvert.DeserializeObject <List <AppUser> >(userData); foreach (var user in users) { using var hmac = new HMACSHA512(); user.UserName = user.UserName.ToLower(); user.PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes("qwerty")); user.PasswordSalt = hmac.Key; context.Users.Add(user); } await context.SaveChangesAsync(); }
public async Task <ActionResult <UserDto> > Login(LoginDto loginDto) { var user = await _context.Users.SingleOrDefaultAsync(x => x.UserName == loginDto.username.ToLower()); if (user == null) { return(Unauthorized("Invalid username")); } using var hmac = new HMACSHA512(user.PasswordSalt); var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(loginDto.password)); for (int i = 0; i < computedHash.Length; i++) { if (computedHash[i] != user.PasswordHash[i]) { return(Unauthorized("Invalid passwrod")); } } return(new UserDto { Username = user.UserName, Token = _tokenService.CreateToken(user) }); }
private static byte[] ComputeHmac(this HashAlgorithmEnum algorithm, byte[] key, byte[] input) { KeyedHashAlgorithm hmacAlgo = new HMACMD5(); switch (algorithm) { case HashAlgorithmEnum.Md5: hmacAlgo = new HMACMD5(key); break; case HashAlgorithmEnum.Sha1: hmacAlgo = new HMACSHA1(key); break; case HashAlgorithmEnum.Sha2256: hmacAlgo = new HMACSHA256(key); break; case HashAlgorithmEnum.Sha2384: hmacAlgo = new HMACSHA384(key); break; case HashAlgorithmEnum.Sha2512: hmacAlgo = new HMACSHA512(key); break; } return(hmacAlgo.ComputeHash(input)); }
public async Task <ActionResult <UserDto> > LoginAsync(LoginDto loginDto) { var user = await _context.Users.SingleOrDefaultAsync(x => x.UserName == loginDto.Username); if (user == null) { return(Unauthorized("Invalid username")); } using var hmac = new HMACSHA512(user.PasswordSalt); var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(loginDto.Password)); if (computedHash.Where((t, i) => t != user.PasswordHash[i]).Any()) { return(Unauthorized("Invalid password")); } return(new UserDto { Username = user.UserName, Token = _tokenService.CreateToken(user) }); }
public async Task <IActionResult> UpdateUser(UserUpdateDto userUpdateDto) { var updateUser = _userRepository.Find(x => x.UserId == userUpdateDto.UserId); if (updateUser == null) { return(BadRequest("User Cant updated")); } else { using var hmac = new HMACSHA512(); var addUser = _mapper.Map <User>(userUpdateDto); updateUser = _mapper.Map <User>(userUpdateDto); updateUser.PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(userUpdateDto.Password)); updateUser.PasswordSalt = hmac.Key; await _userRepository.UpdateAsync(updateUser); return(Ok(updateUser)); } }
public async Task <ActionResult <UserDto> > Register(RegisterDto registerDto) { if (await UserExists(registerDto.Username)) { return(BadRequest("❌ username taken ❌")); } using var hmac = new HMACSHA512(); // disposes itself :) var user = new AppUser { UserName = registerDto.Username.ToLower(), PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registerDto.Password)), PasswordSalt = hmac.Key }; _context.Users.Add(user); // track this object in entity framework, does not yet add to db await _context.SaveChangesAsync(); // NOW we save to the db heehee return(new UserDto { Username = user.UserName, Token = _tokenService.CreateToken(user) }); }
private void btCalculateHash_Click(object sender, EventArgs e) { //TH - Grab the "Response" segment of the rawResponse string. var json_resp_string = txtParsedResponse.Text; //TH - You will need your Client Secret to hash the "Response". string clientSecret = "wtC5Ns0jbtiNA8sP"; //TH - Set your variables Byte[] computedHash; string computedHashString = string.Empty; //TH - Build the hmac using the Client Secret. HMACSHA512 hmac = new HMACSHA512(Encoding.ASCII.GetBytes(clientSecret)); //TH - Compute the hash of the "Response" segment. computedHash = hmac.ComputeHash(Encoding.ASCII.GetBytes(json_resp_string)); //TH - Convert the hash to Base64. computedHashString = Convert.ToBase64String(computedHash); //TH - Display the hashed "Response" segment for comparison to original hash. txtCalculatedHash.Text = computedHashString; }
public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postParameterPosition, ArrayParametersSerialization arraySerialization) { if (!signed) { return(new Dictionary <string, string>()); } if (Credentials.Key == null) { throw new ArgumentException("ApiKey/Secret needed"); } var nonce = parameters.Single(n => n.Key == "nonce").Value; var paramList = parameters.OrderBy(o => o.Key != "nonce"); var pars = string.Join("&", paramList.Select(p => $"{p.Key}={p.Value}")); var result = new Dictionary <string, string> { { "API-Key", Credentials.Key.GetString() } }; var np = nonce + pars; byte[] nonceParamsBytes; using (var sha = SHA256.Create()) nonceParamsBytes = sha.ComputeHash(Encoding.UTF8.GetBytes(np)); var pathBytes = Encoding.UTF8.GetBytes(uri.Split(new[] { ".com" }, StringSplitOptions.None)[1]); var allBytes = pathBytes.Concat(nonceParamsBytes).ToArray(); byte[] sign; lock (encryptor) { sign = encryptor.ComputeHash(allBytes); } result.Add("API-Sign", Convert.ToBase64String(sign)); return(result); }
public (string result, bool Success, string Error) PostToWeb(string apiKey, string apiSecret, string apiUrl, string message) { try { HMACSHA512 hmac = new HMACSHA512(Encoding.UTF8.GetBytes(apiSecret)); byte[] hashmessage = hmac.ComputeHash(Encoding.UTF8.GetBytes(message)); string sign = ToHexString(hashmessage); Client.Headers.Set("Content-Type", "application/json"); Client.Headers.Add("api-key", apiKey); Client.Headers.Add("sign", sign); string result = Client.UploadString(apiUrl, message); if (!string.IsNullOrEmpty(result)) { return(result, true, ""); } return("", false, ""); } catch (Exception Ex) { return("", false, Ex.Message); } }
public async Task AddClient(AddUserDto userDto) { var userFromDb = await _userRepository.GetUserByEmail(userDto.Email); if (userFromDb != null) { throw new Exception("Db contains this email "); } var hmac = new HMACSHA512(); var newUser = new UserClient { Id = Guid.NewGuid(), Email = userDto.Email, FirstName = userDto.FirstName, LastName = userDto.LastName, PhoneNumber = userDto.PhoneNumber, PasswordSalt = hmac.Key, PasswordHash = hmac.ComputeHash(Encoding.ASCII.GetBytes(userDto.Password)) }; await _userRepository.AddUser(newUser); }
public static string krakenQuery(string urlParams, string postData = null) { string uri = "https://api.kraken.com/0/private/" + urlParams; string key = ""; string secret = ""; UInt64 nonce = (UInt64)DateTime.Now.Ticks; //POST Data string data = "nonce=" + nonce.ToString() + postData; //set request properties var request = WebRequest.Create(new Uri(uri)) as HttpWebRequest; request.ContentLength = data.Length; request.Method = "POST"; request.ContentType = "application/x-www-form-urlencoded"; //API-Sign = Message signature using HMAC-SHA512 of (URI path + SHA256(nonce + POST data)) and base64 decoded secret API key byte[] base64DecodedSecret = Convert.FromBase64String(secret); HMACSHA512 hashMaker = new HMACSHA512(base64DecodedSecret); var uriPathByte = Encoding.UTF8.GetBytes("/0/private/" + urlParams); var np = nonce + Convert.ToChar(0) + data; var hashed256np = sha256_hash(np); var z = new byte[uriPathByte.Count() + hashed256np.Count()]; uriPathByte.CopyTo(z, 0); hashed256np.CopyTo(z, uriPathByte.Count()); var signature = hashMaker.ComputeHash(z); request.Headers.Add("API-Key", key); //do crypto stuff, append header request.Headers.Add("API-Sign", Convert.ToBase64String(signature)); //execute using (var writer = new StreamWriter(request.GetRequestStream())) { writer.Write(data); } return(read(request)); }
public string Encrypt(string plainText, out string cipherText) { if (plainText == null || plainText.Length <= 0) { cipherText = default(string); return(string.Empty); } byte[] cipherArray; using (HMACSHA512 hmac = new HMACSHA512(_key)) { var plainTextArray = Encoding.ASCII.GetBytes(plainText); var hash = hmac.ComputeHash(plainTextArray); var salt = GenerateSalt(); using (Aes aes = Aes.Create()) { aes.Key = _key; aes.IV = _iv; ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV); using (MemoryStream memoryStream = new MemoryStream()) { using (CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write)) { cryptoStream.Write(salt, 0, salt.Length); cryptoStream.Write(plainTextArray, 0, plainTextArray.Length); cryptoStream.FlushFinalBlock(); } cipherArray = memoryStream.ToArray(); } } cipherText = Convert.ToBase64String(cipherArray); return(Convert.ToBase64String(hash)); } }
public static string btceQuery(string urlParams) { string key = ""; string secret = ""; HMACSHA512 hashMaker = new HMACSHA512(Encoding.ASCII.GetBytes(secret)); UInt32 unixTimestamp = (UInt32)(DateTime.Now.Subtract(new DateTime(1970, 1, 1))).TotalSeconds; if (unixTimestamp <= lastnonce) { unixTimestamp = lastnonce + 1; } //request url parameters string data = "nonce=" + unixTimestamp.ToString() + urlParams; byte[] dataStream = Encoding.ASCII.GetBytes(data); //set request properties var request = WebRequest.Create(new Uri("https://btc-e.com/tapi")) as HttpWebRequest; request.Method = "POST"; request.ContentType = "application/x-www-form-urlencoded"; request.ContentLength = dataStream.Length; request.Headers.Add("Key", key); //do crypto stuff, append header byte[] hashed = hashMaker.ComputeHash(dataStream); string sign = BitConverter.ToString(hashed); sign = sign.Replace("-", ""); request.Headers.Add("Sign", sign.ToLower()); lastnonce = unixTimestamp; //execute var reqStream = request.GetRequestStream(); reqStream.Write(dataStream, 0, dataStream.Length); reqStream.Close(); return(read(request)); }
public static string CreatePasswordHash(string password, string secretKey) { if (password == null) { throw new ArgumentNullException(nameof(password)); } if (secretKey == null) { throw new ArgumentNullException(nameof(secretKey)); } StringBuilder hash = new StringBuilder(); byte[] passwordBytes = Encoding.UTF8.GetBytes(password); byte[] secretKeyBytes = Encoding.UTF8.GetBytes(secretKey); using (var hmac = new HMACSHA512(secretKeyBytes)) { byte[] hashValue = hmac.ComputeHash(passwordBytes); foreach (var value in hashValue) { hash.Append(value.ToString("x2")); } } return(hash.ToString()); }
public async Task <ActionResult <UserDto> > Register(RegisterDto registerDto) { if (await UserExists(registerDto.Username)) { return(BadRequest("Username is taken")); } var user = _mapper.Map <AppUser>(registerDto); user.UserName = registerDto.Username.ToLower(); using var hmac = new HMACSHA512(); // using disposes of the object when no longer needed user.PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registerDto.Password)); user.PasswordSalt = hmac.Key; _context.Users.Add(user); // the user is only tracked await _context.SaveChangesAsync(); // now it's saved in the DB return(new UserDto { Username = user.UserName, Token = _tokenService.CreateToken(user), KnownAs = user.KnowsAs }); }
public void SubmitScore() { SubmitPanel.SetActive(false); AllScorePanels.SetActive(true); playerId = Guid.NewGuid().ToString().Replace("-", ""); Hashtable data = new Hashtable(); data.Add("playerId", playerId); data.Add("name", Name.text.Substring(0, Name.text.Length > 15 ? 15 : Name.text.Length)); data.Add("score", GameManager.Instance.score); string key = LeaderboardId + data["playerId"] + data["score"]; var bytes = Encoding.UTF8.GetBytes(LeaderboardSecret); using (var hmacsha512 = new HMACSHA512(bytes)) { hmacsha512.ComputeHash(Encoding.UTF8.GetBytes(key)); data.Add("signature", ByteToString(hmacsha512.Hash).ToLower()); } #if UNITY_WEBPLAYER Application.ExternalCall("submitScore", LeaderboardId, data["playerId"], data["name"], data["score"], data["signature"], "ScoreBoardCanvas", "SubmitCallback"); #else HTTP.Request theRequest = new HTTP.Request("put", "https://api.leaderboards.io/leaderboard/" + LeaderboardId + "/score", data); theRequest.Send((request) => { Hashtable result = request.response.Object; if (result != null) { SubmitCallback(); } }); #endif }
public static int Main() { byte[] key = ParseHexBytes(KeyStr); byte[] data = ParseHexBytes(DataStr); byte[] hash384Correct = ParseHexBytes(Hash384CorrectStr); byte[] hash384Legacy = ParseHexBytes(Hash384LegacyStr); byte[] hash512Correct = ParseHexBytes(Hash512CorrectStr); byte[] hash512Legacy = ParseHexBytes(Hash512LegacyStr); // HMAC-SHA-384 with legacy property set -> legacy result // HMACSHA384 hm384Legacy = new HMACSHA384(key); hm384Legacy.ProduceLegacyHmacValues = true; byte[] result384Legacy = hm384Legacy.ComputeHash(data); if (!CompareBytes(result384Legacy, hash384Legacy)) { Console.WriteLine("HMACSHA384 - ProductLegacyHmacValues=true failed"); return FailCode; } // HMAC-SHA-384 with legacy property not set -> correct result // HMACSHA384 hm384Correct = new HMACSHA384(key); hm384Correct.ProduceLegacyHmacValues = false; byte[] result384Correct = hm384Correct.ComputeHash(data); if (!CompareBytes(result384Correct, hash384Correct)) { Console.WriteLine("HMACSHA384 - ProduceLegacyHmacValues=false failed"); return FailCode; } // HMAC-SHA-384 with legacy property not set -> default result (correct) // HMACSHA384 hm384Default = new HMACSHA384(key); byte[] result384Default = hm384Default.ComputeHash(data); if (!CompareBytes(result384Default, hash384Correct)) { Console.WriteLine("HMACSHA384 - ProduceLegacyHmacValues=default failed"); return FailCode; } // HMAC-SHA-512 with legacy property set -> legacy result // HMACSHA512 hm512Legacy = new HMACSHA512(key); hm512Legacy.ProduceLegacyHmacValues = true; byte[] result512Legacy = hm512Legacy.ComputeHash(data); if (!CompareBytes(result512Legacy, hash512Legacy)) { Console.WriteLine("HMACSHA512 - ProduceLegacyHmacValues=true failed"); return FailCode; } // HMAC-SHA-512 with legacy property not set -> correct result // HMACSHA512 hm512Correct = new HMACSHA512(key); hm512Correct.ProduceLegacyHmacValues = false; byte[] result512Correct = hm512Correct.ComputeHash(data); if (!CompareBytes(result512Correct, hash512Correct)) { Console.WriteLine("HMACSHA512 - ProduceLegacyHmacValues=false failed"); return FailCode; } // HMAC-SHA-512 with legacy property not set -> default result (correct) // HMACSHA512 hm512Default = new HMACSHA512(key); byte[] result512Default = hm512Default.ComputeHash(data); if (!CompareBytes(result512Default, hash512Correct)) { Console.WriteLine("HMACSHA512 - ProduceLegacyHmacValues=default failed"); return FailCode; } Console.WriteLine("Test passed"); return PassCode; }