static OkcCNHelper() { api_key = SQL.get_value("cnokc_api_key"); secret_key = SQL.get_value("cnokc_secret_key"); hash_mark = new HMACSHA512(Encoding.ASCII.GetBytes(SQL.get_value("cnokc_hash_key"))); nonce = UnixTime.unix_now; }
static HuobiHelper() { api_key = SQL.get_value("huobi_api_key"); secret_key = SQL.get_value("houbi_secret_key"); hash_mark = new HMACSHA512(Encoding.ASCII.GetBytes(SQL.get_value("huobi_hash_key"))); nonce = UnixTime.unix_now; }
static BtctradeHelper() { api_key = SQL.get_value("btctrade_api_key"); secret_key = SQL.get_value("btctrade_secret_key"); hash_mark = new HMACSHA512(Encoding.ASCII.GetBytes(SQL.get_value("btctrade_hash_key"))); nonce = UnixTime.unix_now; }
public async Task <ActionResult <UserDto> > Login(LoginDto loginDto) { var user = await _context.User.SingleOrDefaultAsync(x => x.UserName == loginDto.UserName.ToLower()); if (user == null) { return(Unauthorized("UserName or Password Do not match! Please try again")); } 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("UserName or Password Do not match! Please try again")); } } return(new UserDto { UserName = user.UserName, Token = _tokenService.CreateToken(user) }); }
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 async Task <ActionResult <UserDto> > 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(System.Text.Encoding.UTF8.GetBytes(loginDto.Password)); for (int i = 0; i < ComputeHash.Length; i++) { if (ComputeHash[i] != user.PasswordHash[i]) { return(Unauthorized("Invalid Password")); } } return(new UserDto { Username = user.UserName, Token = _tokenService.CreateToken(user) }); }
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 <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> > Login(LoginDto model) { var user = await _context.Users.FirstOrDefaultAsync(x => x.UserName == model.Username.ToLower()); if (user == null) { return(Unauthorized("username doesn't exists")); } using var hmac = new HMACSHA512(user.PasswordSalt); var computedhash = hmac.ComputeHash(Encoding.UTF8.GetBytes(model.Password)); for (int i = 0; i < computedhash.Length; i++) { if (computedhash[i] != user.PasswordHash[i]) { return(Unauthorized("Invalid Password")); } } return(new UserDto { Username = user.UserName, Token = _tokenservice.CreateToken(user) }); }
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 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) }); }
public async Task <ActionResult <UserDto> > Login(LoginDto loginDto) { var user = await _context.User.SingleOrDefaultAsync(x => x.UserName == loginDto.Username); if (user == null) { return(Unauthorized("'" + loginDto.Username + "' is an invalid username")); } using var hmac = new HMACSHA512(user.PasswordSalt); var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(loginDto.Password)); if (!Enumerable.SequenceEqual(computedHash, user.PasswordHash)) { return(Unauthorized("Invalid password")); } return(new UserDto { Username = user.UserName, Token = _tokenService.CreateToken(user) }); }
public bool VerifyPasswordHash(string password, string hash, string salt) { var hashBytes = Convert.FromBase64String(hash); var saltBytes = Convert.FromBase64String(salt); if (password == null) { throw new ArgumentNullException(nameof(password)); } if (string.IsNullOrWhiteSpace(password)) { throw new ArgumentException("Value cannot be empty or whitespace only string.", nameof(password)); } if (hashBytes.Length != 64) { throw new ArgumentException("Invalid length of password hash (64 bytes expected).", nameof(hashBytes)); } if (saltBytes.Length != 128) { throw new ArgumentException("Invalid length of password salt (128 bytes expected).", nameof(saltBytes)); } using (var hmac = new HMACSHA512(saltBytes)) { var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(password)); for (var i = 0; i < computedHash.Length; i++) { if (computedHash[i] != hashBytes[i]) { return(false); } } } return(true); }
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 <UserDto> Register(RegisterDto dto) { if (await _userRepository.UserExistsAsync(dto.Login)) { throw new UnauthorizedException("Ten login jest już zajęty"); } using var hmac = new HMACSHA512(); var user = new User { Login = dto.Login, PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(dto.Password)), PasswordSalt = hmac.Key }; await _userRepository.AddAsync(user); return(new UserDto { Id = user.Id, Login = user.Login, Token = _tokenService.CreateToken(user) }); }
public async Task <ActionResult <UserDto> > Register(RegisterDto registerDto) { if (await UserExists(registerDto.Username)) { return(BadRequest("Username is taken")); } using var hmac = new HMACSHA512(); var user = new AppUser { UserName = registerDto.Username, PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registerDto.Password)), PasswordSalt = hmac.Key }; _ctx.Users.Add(user); await _ctx.SaveChangesAsync(); return(new UserDto { Username = user.UserName, Token = _tokenService.CreateToken(user) }); }
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 string GenerateOtp(int input) { // Since .net uses little endian numbers, we need to reverse the byte order to get big endian. var data = BitConverter.GetBytes((long)input); Array.Reverse(data); HMAC hmac = null; switch (this.digest) { case Digest.Sha256: hmac = new HMACSHA256(); break; case Digest.Sha512: hmac = new HMACSHA512(); break; default: //case Digest.Sha1: hmac = new HMACSHA1(); break; } hmac.Key = Base32.Decode(this.secret); byte[] hashedValue = hmac.ComputeHash(data); int offset = hashedValue[hashedValue.Length - 1] & 0x0F; long result = (hashedValue[offset] & 0x7f) << 24 | (hashedValue[offset + 1] & 0xff) << 16 | (hashedValue[offset + 2] & 0xff) << 8 | (hashedValue[offset + 3] & 0xff) % 1000000; var truncatedValue = ((int)result % (int)Math.Pow(10, this.digits)); return(truncatedValue.ToString().PadLeft(this.digits, '0')); }
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); } }
/// <summary> /// Derives the locator. /// </summary> /// <returns>The locator.</returns> /// <param name="index_id">Index_id.</param> /// <param name="replication">Replication.</param> public string DeriveLocator(byte[] index_id, UInt32 replication) { string final; using (MemoryStream ms = new MemoryStream()) { byte[] replication_bytes = BitConverter.GetBytes(replication); if (replication_bytes.Length != 4) { throw new Exception("replication length mismatch"); } ms.Write(replication_bytes, 0, replication_bytes.Length); ms.Write(index_id, 0, index_id.Length); long written = ms.Position; using (var hmacAlgorithm = new HMACSHA512(identifier.PinpointingKey)) { byte[] result = Helpers.Cryptography.HashBlock(hmacAlgorithm, ms, 0, written); final = Helpers.Encoding.ByteArrayToHexString(result); return(final); } } }
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)); } }
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 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 <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); }
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); }
/// <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); }
public static async Task SeedUsers(DataContext context) { if (await context.Users.AnyAsync()) { return; } var userData = await System.IO.File.ReadAllTextAsync("Data/UserSeedData.json"); var users = JsonSerializer.Deserialize <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("Pa$$w0rd")); user.PasswordSalt = hmac.Key; context.Users.Add(user); } await context.SaveChangesAsync(); }
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 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 Hash(string plainText, string privateKey, int cipherStrength) { try { byte[] KeyBytes = Encoder.GetBytes(privateKey); HMAC Cipher = null; if (cipherStrength == 1) { Cipher = new HMACSHA1(KeyBytes); } else if (cipherStrength == 256) { Cipher = new HMACSHA256(KeyBytes); } else if (cipherStrength == 384) { Cipher = new HMACSHA384(KeyBytes); } else if (cipherStrength == 512) { Cipher = new HMACSHA512(KeyBytes); } else { throw new Exception("Enter a valid cipher strength."); } byte[] PlainBytes = Encoder.GetBytes(plainText); byte[] HashedBytes = Cipher.ComputeHash(PlainBytes); return(Convert.ToBase64String(HashedBytes)); } catch (Exception ex) { //Don't log here. Logging should be down in calling method. throw ex; } }
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 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 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 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; }
public void ProduceLegacyHmacValues() { using (var h = new HMACSHA512()) { Assert.False(h.ProduceLegacyHmacValues); h.ProduceLegacyHmacValues = false; // doesn't throw Assert.Throws<PlatformNotSupportedException>(() => h.ProduceLegacyHmacValues = true); } }
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 }