public void Load(BinaryReader br) { br.ReadByte(); // version byte[] Bytes = br.ReadBytes(20); Hash = SHA1Hash.FromBytes(Bytes); }
public async Task<string> Decrypt(string encryptedPremiumToken, string apiKey) { var aes = new Aes(); var sha1 = new SHA1Hash(); var keyHash = await sha1.GetHashAsync(apiKey).ConfigureAwait(false); var unencryptedPremiumToken = await aes.DecryptAsync(encryptedPremiumToken, keyHash).ConfigureAwait(false); return unencryptedPremiumToken; }
public NodesWithHash(double[] lats, double[] lons) { this.lats = lats; this.lons = lons; int N = lats.Length; int elemSize = sizeof(double); byte[] bytes = new byte[N * 3 * elemSize]; for (int i = 0; i < N; i++) { byte[] h1 = BitConverter.GetBytes(lats[i]); byte[] h2 = BitConverter.GetBytes(lons[i]); Buffer.BlockCopy(h1, 0, bytes, elemSize * i * 2, elemSize); Buffer.BlockCopy(h2, 0, bytes, elemSize * i * 2 + elemSize, elemSize); } hash = SHA1Hash.HashAsync(bytes).Result; hashCode = BitConverter.ToInt32(BitConverter.GetBytes(hash), 0); }
public void SHA1_Should_CalculateCorrectHashBytes_When_ProvidedStream() { // Arrange var expected = new byte[] { 0xb2, 0x9f, 0xe3, 0xad, 0x6f, 0xd6, 0x8c, 0x8b, 0x2c, 0x71, 0xc6, 0x09, 0x94, 0x89, 0x29, 0x52, 0x5d, 0x21, 0x85, 0xd2 }; byte[] actual; // Act using (var sr = new StreamReader($"{_assemblyPath}gettysburg.txt")) { actual = SHA1Hash.Create().ComputeToBytes(sr.BaseStream); } // Assert Assert.Equal(expected, actual); }
public void SHA1_Should_CalculateCorrectHashBytes_When_ProvidedWithBytes() { // Arrange var data = new byte[] { 0x55, 0x6e, 0x69, 0x74, 0x54, 0x65, 0x73, 0x74 }; var expected = new byte[] { 0xce, 0x04, 0xfe, 0x35, 0x7b, 0xc6, 0x7b, 0xe9, 0xbe, 0x8f, 0x97, 0xf0, 0xa0, 0x7e, 0x36, 0xdc, 0x7b, 0x63, 0xed, 0xfc }; // Act var actual = SHA1Hash.Create().ComputeToBytes(data); // Assert Assert.Equal(expected, actual); }
public IActionResult SHA1Encrypt([FromBody] HashViewModel viewModel) { SHA1Hash hash = new SHA1Hash(); string encrypted = ""; try { encrypted = hash.Encrypt(viewModel.Message); } catch (NullReferenceException) { } catch (Exception) { return(BadRequest(new { Result = false, Message = Text.InvalidCharacter })); } return(Json(encrypted)); }
public void ShouldHashReadOnlySpan() { using (var sha1 = new SHA1Hash()) { var data = new byte[1] { 49 }; sha1.UpdateData(data); sha1.Finish(); Assert.AreEqual("356A192B7913B04C54574D18C28D46E6395428AB", ByteArrayToHexStr(sha1.GetDigest())); sha1.Initialize(); data = new byte[2] { 49, 50 }; sha1.UpdateData(data); sha1.Finish(); Assert.AreEqual("7B52009B64FD0A2A49E6D8A939753077792B0554", ByteArrayToHexStr(sha1.GetDigest())); } }
public NodesWithHash(double[] lats, double[] lons, double[] vals) : base(lats, lons, vals) { int N = lats.Length; int elemSize = sizeof(double); byte[] bytes = new byte[N * 3 * elemSize]; for (int i = 0; i < N; i++) { byte[] h1 = BitConverter.GetBytes(Lats[i]); byte[] h2 = BitConverter.GetBytes(Lons[i]); byte[] h3 = BitConverter.GetBytes(Values[i]); Buffer.BlockCopy(h1, 0, bytes, elemSize * i * 3, elemSize); Buffer.BlockCopy(h2, 0, bytes, elemSize * i * 3 + elemSize, elemSize); Buffer.BlockCopy(h3, 0, bytes, elemSize * i * 3 + 2 * elemSize, elemSize); } hash = SHA1Hash.HashAsync(bytes).Result; hashCode = BitConverter.ToInt32(BitConverter.GetBytes(hash), 0); }
public void TestSHA1() { HashAdapter hash = new SHA1Hash(); string src1 = @"ABC"; string result1 = hash.ComputeHash(src1); Assert.AreEqual(40, result1.Length); string hashed1 = @"3c01bdbb26f358bab27f267924aa2c9a03fcfdb8"; Assert.AreEqual(hashed1, result1); // 日本語を含む文字列は? string src2 = @"あいう"; string result2 = hash.ComputeHash(src2); Assert.AreEqual(40, result2.Length); string hashed2 = @"eb636ba7c320e00b3749ad404b7adc7609560dee"; Assert.AreEqual(hashed2, result2); }
private string ToStringAncestorUnids(int indent) { const int xNamePad = 16; string indentString = "".PadRight(indent); var sb = new StringBuilder(); sb.Append(indentString); var correlationStatus = ""; if (CorrelationStatus != CorrelationStatus.Nil) { correlationStatus = $"[{CorrelationStatus.ToString().PadRight(8)}] "; } if (ContentElement.Name == W.t || ContentElement.Name == W.delText) { sb.AppendFormat( "Atom {0}: {1} {2} SHA1:{3} ", PadLocalName(xNamePad, this), ContentElement.Value, correlationStatus, SHA1Hash.Substring(0, 8)); AppendAncestorsUnidsDump(sb, this); } else { sb.AppendFormat( "Atom {0}: {1} SHA1:{2} ", PadLocalName(xNamePad, this), correlationStatus, SHA1Hash.Substring(0, 8)); AppendAncestorsUnidsDump(sb, this); } return(sb.ToString()); }
public bool LoadChunk(SHA1Hash id, long variantSize, long originalSize, Stream output, bool noPatching) { ChunkLoader chunkLoader; List <ChunkVariantInfo> chunkVariants; if (this.FindChunk(id, out chunkLoader, out chunkVariants) == false) { return(false); } foreach (var chunkVariant in chunkVariants) { var type = chunkVariant.Type; var index = chunkVariant.Index; if (type == ChunkVariantType.Normal) { if (this.LoadNormalChunk(chunkLoader, index, variantSize, originalSize, output) == true) { return(true); } } else if (noPatching == false && type == ChunkVariantType.Patch) { if (this.LoadPatchChunk(chunkLoader, index, variantSize, originalSize, output) == true) { return(true); } } else if (type == ChunkVariantType.Encrypted) { if (this.LoadEncryptedChunk(chunkLoader, index, variantSize, originalSize, output) == true) { return(true); } } } return(false); }
public void ShouldHashAsStandardSha1() { using (var sha1 = new SHA1Hash()) { var data1 = new byte[1] { 49 }; var data2 = new byte[2] { 49, 50 }; sha1.UpdateData(data1); sha1.UpdateData(data2); sha1.Finish(); var stdSha1 = System.Security.Cryptography.SHA1.Create(); stdSha1.TransformBlock(data1, 0, 1, null, 0); stdSha1.TransformBlock(data2, 0, 2, null, 0); stdSha1.TransformFinalBlock(Array.Empty <byte>(), 0, 0); CollectionAssert.AreEqual(sha1.GetDigest().ToArray(), stdSha1.Hash); } }
public static byte[] Get411Password(string password, string seed) { if (password.Length == 0) { return(new byte[1]); } SHA1Hash hash = new SHA1Hash(); byte[] buffer = hash.ComputeHash(Encoding.Default.GetBytes(password)); byte[] sourceArray = hash.ComputeHash(buffer); byte[] bytes = Encoding.Default.GetBytes(seed); byte[] destinationArray = new byte[bytes.Length + sourceArray.Length]; Array.Copy(bytes, 0, destinationArray, 0, bytes.Length); Array.Copy(sourceArray, 0, destinationArray, bytes.Length, sourceArray.Length); byte[] buffer5 = hash.ComputeHash(destinationArray); byte[] buffer6 = new byte[buffer5.Length + 1]; buffer6[0] = 20; Array.Copy(buffer5, 0, buffer6, 1, buffer5.Length); for (int i = 1; i < buffer6.Length; i++) { buffer6[i] = (byte)(buffer6[i] ^ buffer[i - 1]); } return(buffer6); }
public bool GetChunkId(Guid guid, out SHA1Hash sha1, out long size) { var superbundleChunkInfo = this._Superbundles .Values .Where(sb => sb.Bundles != null) .SelectMany(sb => sb.Bundles) .Where(bi => bi.Chunks != null) .SelectMany(bi => bi.Chunks) .FirstOrDefault(ci => ci.Id == guid); if (superbundleChunkInfo != null) { sha1 = superbundleChunkInfo.SHA1; size = superbundleChunkInfo.Size; return(true); } var tableOfContentsChunkInfo = this._TableOfContents .Values .Where(toc => toc.Chunks != null) .SelectMany(toc => toc.Chunks) .FirstOrDefault(ci => ci.Id == guid); if (tableOfContentsChunkInfo != null) { sha1 = tableOfContentsChunkInfo.SHA1; size = 0; return(true); } sha1 = default(SHA1Hash); size = 0; return(false); }
/// <summary> /// Generate a scrambled password for 4.1.0 using new passwords /// </summary> /// <param name="password">The password to scramble</param> /// <param name="seedBytes">The seedbytes used to scramble</param> /// <returns>Array of bytes containing the scrambled password</returns> public static byte[] Get410Password(string password, byte[] seedBytes) { SHA1Hash sha = new SHA1Hash(); //SHA1 sha = new SHA1CryptoServiceProvider(); // clean it and then digest it password = password.Replace(" ", "").Replace("\t", ""); byte[] passBytes = System.Text.Encoding.Default.GetBytes(password); byte[] firstPass = sha.ComputeHash(passBytes); byte[] input = new byte[24]; Array.Copy(seedBytes, 0, input, 0, 4); Array.Copy(firstPass, 0, input, 4, 20); byte[] secondPass = sha.ComputeHash(input); byte[] scrambledBuff = new byte[20]; XorScramble(seedBytes, 4, scrambledBuff, 0, secondPass, 20); byte[] finalBuff = new byte[20]; XorScramble(scrambledBuff, 0, finalBuff, 0, firstPass, 20); return(finalBuff); }
async Task <PremiumAccessToken> GetPremiumTokenInternal(string encryptedPremiumToken, string apiKey) { var premiumToken = DomainEvilGlobal.Settings.AccountOptions.UserInfo.Token; try { var premiumCached = _firstCompleted && premiumToken.IsPremium() && premiumToken.IsValidInNearFuture(); if (!premiumCached) { var aes = new Aes(); var sha1 = new SHA1Hash(); var keyHash = await sha1.GetHashAsync(apiKey).ConfigureAwait(false); var unencryptedPremiumToken = await aes.DecryptAsync(encryptedPremiumToken, keyHash).ConfigureAwait(false); premiumToken = JsonConvert.DeserializeObject <PremiumAccessToken>(unencryptedPremiumToken); } } catch (NotPremiumUserException) { premiumToken = null; } return(premiumToken); }
async Task<PremiumAccessToken> GetPremiumTokenInternal(string encryptedPremiumToken, string apiKey) { var premiumToken = _settings.AccountOptions.UserInfo.Token; try { var premiumCached = _firstCompleted && premiumToken.IsPremium() && premiumToken.IsValidInNearFuture(); if (!premiumCached) { var aes = new Aes(); var sha1 = new SHA1Hash(); var keyHash = await sha1.GetHashAsync(apiKey).ConfigureAwait(false); var unencryptedPremiumToken = await aes.DecryptAsync(encryptedPremiumToken, keyHash).ConfigureAwait(false); premiumToken = JsonConvert.DeserializeObject<PremiumAccessToken>(unencryptedPremiumToken); } } catch (NotPremiumUserException) { premiumToken = null; } return premiumToken; }
// Methods public override async Task <StepResults> Perform(Dictionary <string, object> variableCache, IProgress <ProgressReport> progress) { var column = StartMessage.Trim().Length > 0 ? ": " : ""; var progressReport = new ProgressReport(); var stepResults = new StepResults { Message = column + Common.ProcessVariableTokens(ValidMessage, variableCache), Status = StepStatus.Success }; progress.Report(new ProgressReport { Message = Common.ProcessVariableTokens(StartMessage, variableCache), Percentage = 0, NewLine = false }); await Task.Delay(10); if ((Variable == string.Empty && Path == string.Empty) || (Variable != string.Empty && !variableCache.ContainsKey(Variable))) { stepResults.Message = $"{column}A file was not provided."; stepResults.Status = StepStatus.Failure; } else if (Hash == string.Empty) { stepResults.Message = $"{column}A hash was not provided."; stepResults.Status = StepStatus.Failure; } var file = string.Empty; if (stepResults.Status == StepStatus.Success) { if (variableCache.ContainsKey(Variable)) { file = variableCache[Variable].ToString(); } else { file = Common.ProcessVariableTokens(Path, variableCache); } if (!File.Exists(file)) { stepResults.Message = $"{column}The file provided does not exist."; stepResults.Status = StepStatus.Failure; } } var result = string.Empty; if (stepResults.Status == StepStatus.Success) { switch (Type) { case HashTypes.None: stepResults.Message = $"{column}A hash type was not selected."; stepResults.Status = StepStatus.Failure; break; case HashTypes.SHA1: result = await SHA1Hash.ComputeHashAsync(File.OpenRead(file), progress); if (Hash.ToUpper() != result) { stepResults.Message = $"\r\nExpected {Hash.ToUpper()} but got {result.ToUpper()} instead.\r\n" + Common.ProcessVariableTokens(InvalidMessage, variableCache); stepResults.Status = StepStatus.Failure; } break; case HashTypes.SHA256: result = await SHA256Hash.ComputeHashAsync(File.OpenRead(file), progress); if (Hash.ToUpper() != result) { stepResults.Message = $"\r\nExpected {Hash.ToUpper()} but got {result.ToUpper()} instead.\r\n" + Common.ProcessVariableTokens(InvalidMessage, variableCache); stepResults.Status = StepStatus.Failure; } break; } } progress.Report(progressReport); return(stepResults); }
public void Sha1(string a, ulong hash) { IFileHash h = new SHA1Hash(); Assert.Equal(hash, h.GetHash(Encoding.Unicode.GetBytes(a))); }
// Methods public override async Task <StepResults> Perform(Dictionary <string, object> variableCache, IProgress <ProgressReport> progress) { var progressReport = new ProgressReport(); var stepResults = new StepResults { Message = Common.ProcessVariableTokens(ValidMessage, variableCache), Status = StepStatus.Success }; Hash = Hash.ToUpper(); progress.Report(new ProgressReport { Message = StartMessage, Percentage = 0 }); if (Variable == string.Empty || !variableCache.ContainsKey(Variable)) { stepResults.Message = $"{Name}: A file was not provided."; stepResults.Status = StepStatus.Failure; } else if (!File.Exists(variableCache[Variable].ToString())) { stepResults.Message = $"{Name}: The file provided does not exist."; stepResults.Status = StepStatus.Failure; } else if (Hash == string.Empty) { stepResults.Message = $"{Name}: A hash was not provided."; stepResults.Status = StepStatus.Failure; } var result = string.Empty; if (stepResults.Status == StepStatus.Success) { switch (Type) { case HashTypes.None: stepResults.Message = $"{Name}: A hash type was not selected."; stepResults.Status = StepStatus.Failure; break; case HashTypes.SHA1: result = await SHA1Hash.ComputeHashAsync(File.OpenRead(variableCache[Variable].ToString()), progress); if (Hash != result) { stepResults.Message = $"Expected {Hash} but got {result} instead.\r\n" + Common.ProcessVariableTokens(InvalidMessage, variableCache); stepResults.Status = StepStatus.Failure; } break; case HashTypes.SHA256: result = await SHA256Hash.ComputeHashAsync(File.OpenRead(variableCache[Variable].ToString()), progress); if (Hash != result) { stepResults.Message = $"Expected {Hash} but got {result} instead.\r\n" + Common.ProcessVariableTokens(InvalidMessage, variableCache); stepResults.Status = StepStatus.Failure; } break; } } progress.Report(progressReport); return(stepResults); }
internal ModReleaseInfo(AccurateVersion version, string downloadUrl, string fileName, DateTime releaseDate, SHA1Hash checksum, ModInfo info) => (Version, DownloadUrl, FileName, ReleaseDate, Checksum, Info)
protected void LoginButton_Click(object sender, EventArgs e) { string senha = SHA1Hash.SHA1UTF8(Login1.Password); hashgen.Value = senha; }
public void SHA1HashConstructorTest() { SHA1Hash target = new SHA1Hash(); Assert.Inconclusive("TODO: Implement code to verify target"); }
public EstimationResult EstimateAlgorithm(ISearchAlgorithm algorithm, object parameters = null) { if (algorithm == null) { throw new ArgumentNullException("algorithm"); } Dictionary <SHA1Hash, Dictionary <SHA1Hash, int> > AutoScores = new Dictionary <SHA1Hash, Dictionary <SHA1Hash, int> >(); List <Audio> Audios = Core.GetAudios().ToList(); List <Audio> ReferenceList = Audios.ToList(); foreach (Audio ReferenceAudio in ReferenceList) { IList <Audio> Series = Audios.Search(ReferenceAudio, algorithm, parameters) .Where(audio => HashMap.Contains(audio.GetHash())) .ToList(); SHA1Hash ReferenceHash = ReferenceAudio.GetHash(); AutoScores.Add(ReferenceHash, new Dictionary <SHA1Hash, int>()); int Rank = 0; foreach (Audio TargetAudio in Series) { AutoScores[ReferenceHash].Add(TargetAudio.GetHash(), TransformRankToScore(Rank++, Series.Count)); } } List <double> Errors = new List <double>(); List <double> ManualScoresList = new List <double>(); List <double> ReducedAutoScoresList = new List <double>(); foreach (SHA1Hash Reference in ManualScores.Keys) { foreach (SHA1Hash Target in ManualScores[Reference].Keys) { if (AutoScores.ContainsKey(Reference) && AutoScores[Reference].ContainsKey(Target)) { int ReferenceScore = ManualScores[Reference][Target]; int AutoScore = AutoScores[Reference][Target]; int Error = ReferenceScore - AutoScore; Errors.Add(Error); ManualScoresList.Add(ReferenceScore); ReducedAutoScoresList.Add(AutoScore); } } } double Mean = Errors.Mean(); double StandardDeviation = Errors.StandardDeviation(); double Covariance = ManualScoresList.Covariance(ReducedAutoScoresList); double PearsonCoeff = Correlation.Pearson(ManualScoresList, ReducedAutoScoresList); EstimationResult Result = new EstimationResult() { AlgorithmName = algorithm.DisplayName, Parameters = Convert.ToString(parameters), Mean = Mean, StandardDeviation = StandardDeviation, Covariance = Covariance, PearsonCoeff = PearsonCoeff, Scores = AutoScores }; return(Result); }
/// <summary> /// Generates a proper hash for old style 4.1.0 passwords. This would be used /// if a 4.1.0 server contained old 16 byte hashes. /// </summary> /// <param name="password">The password to hash</param> /// <param name="seedBytes">Seed bytes received from the server</param> /// <returns>Byte array containing the password hash</returns> public static byte[] GetOld410Password(string password, byte[] seedBytes) { long[] passwordHash = Hash(password); string passHex = String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0,8:X}{1,8:X}", passwordHash[0], passwordHash[1]); int[] salt = getSaltFromPassword(passHex); // compute binary password byte[] binaryPassword = new byte[20]; int offset = 0; for (int i = 0; i < 2; i++) { int val = salt[i]; for (int t = 3; t >= 0; t--) { binaryPassword[t + offset] = (byte)(val % 256); val >>= 8; /* Scroll 8 bits to get next part*/ } offset += 4; } //SHA1 sha = new SHA1CryptoServiceProvider(); SHA1Hash sha = new SHA1Hash(); byte[] temp = new byte[8]; Buffer.BlockCopy(binaryPassword, 0, temp, 0, 8); byte[] binaryHash = sha.ComputeHash(temp); byte[] scrambledBuff = new byte[20]; XorScramble(seedBytes, 4, scrambledBuff, 0, binaryHash, 20); string scrambleString = System.Text.Encoding.Default.GetString(scrambledBuff, 0, scrambledBuff.Length).Substring(0, 8); long[] hashPass = Hash(password); long[] hashMessage = Hash(scrambleString); long max = 0x3FFFFFFFL; byte[] to = new byte[20]; int msgPos = 0; int msgLength = scrambleString.Length; int toPos = 0; long seed1 = (hashPass[0] ^ hashMessage[0]) % max; long seed2 = (hashPass[1] ^ hashMessage[1]) % max; while (msgPos++ < msgLength) { to[toPos++] = (byte)(Math.Floor(rand(ref seed1, ref seed2, max) * 31) + 64); } /* Make it harder to break */ byte extra = (byte)(Math.Floor(rand(ref seed1, ref seed2, max) * 31)); for (int i = 0; i < 8; i++) { to[i] ^= extra; } return(to); }
public bool LoadChunk(SHA1Hash id, long variantSize, long originalSize, Stream output) { return(this.LoadChunk(id, variantSize, originalSize, output, false)); }