public TransformBlock ( byte inputBuffer, int inputOffset, int inputCount, byte outputBuffer, int outputOffset ) : int | ||
inputBuffer | byte | |
inputOffset | int | |
inputCount | int | |
outputBuffer | byte | |
outputOffset | int | |
return | int |
public void ComputeHash(HashAlgorithm hash) { byte[] tmp = Encoding.UTF8.GetBytes (_name); hash.TransformBlock (tmp, 0, tmp.Length, null, 0); tmp = Encoding.UTF8.GetBytes (_body); hash.TransformBlock (tmp, 0, tmp.Length, null, 0); }
/// <summary>Calculates the hash for a Leaf node.</summary> /// <param name="data">The data to hash.</param> /// <param name="offset">Where in the data array to start hashing.</param> /// <param name="count">How many bytes in the data array to hash.</param> /// <returns>The resulting Leaf hash.</returns> protected byte[] LeafHash(byte[] data, int offset, int count) { hashAlgorithm.Initialize(); hashAlgorithm.TransformBlock(new byte[1] { 0 }, 0, 1, null, 0); hashAlgorithm.TransformFinalBlock(data, offset, count); return(hashAlgorithm.Hash); }
public void WriteHash(HashAlgorithm hash, DocPosition docPos, AncestralNamespaceContextManager anc) { UTF8Encoding encoding = new UTF8Encoding(false); byte[] bytes = encoding.GetBytes(" " + this.Name + "=\""); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); bytes = encoding.GetBytes(System.Security.Cryptography.Xml.Utils.EscapeAttributeValue(this.Value)); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); bytes = encoding.GetBytes("\""); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); }
protected int StartTests(HashAlgorithm hash, byte[] input, byte[] result) { try { byte[] ch = hash.ComputeHash(input, 0, input.Length); if (!ArrayEquals(ch, result)) AddError("HB-ST1"); } catch { AddError("HB-ST2"); } try { // feed input byte-by-byte for(int i = 0; i < input.Length - 1; i++) { hash.TransformBlock(input, i, 1, input, i); } if (input.Length > 0) hash.TransformFinalBlock(input, input.Length - 1, 1); else hash.TransformFinalBlock(input, 0, 0); if (!ArrayEquals(hash.Hash, result)) { AddError("HB-ST3"); Console.WriteLine(Encoding.ASCII.GetString(input)); } } catch { AddError("HB-ST4"); } finally { hash.Initialize(); } return 4; }
/// <summary>Generates and returns a mask from the specified random seed of the specified length.</summary> /// <param name="rgbSeed">The random seed to use for computing the mask. </param> /// <param name="cbReturn">The length of the generated mask in bytes. </param> /// <returns>A randomly generated mask whose length is equal to the <paramref name="cbReturn" /> parameter.</returns> // Token: 0x06002244 RID: 8772 RVA: 0x000790F8 File Offset: 0x000772F8 public override byte[] GenerateMask(byte[] rgbSeed, int cbReturn) { HashAlgorithm hashAlgorithm = (HashAlgorithm)CryptoConfig.CreateFromName(this.HashNameValue); byte[] inputBuffer = new byte[4]; byte[] array = new byte[cbReturn]; uint num = 0U; for (int i = 0; i < array.Length; i += hashAlgorithm.Hash.Length) { Utils.ConvertIntToByteArray(num++, ref inputBuffer); hashAlgorithm.TransformBlock(rgbSeed, 0, rgbSeed.Length, rgbSeed, 0); hashAlgorithm.TransformFinalBlock(inputBuffer, 0, 4); byte[] hash = hashAlgorithm.Hash; hashAlgorithm.Initialize(); if (array.Length - i > hash.Length) { Buffer.BlockCopy(hash, 0, array, i, hash.Length); } else { Buffer.BlockCopy(hash, 0, array, i, array.Length - i); } } return(array); }
/// <summary>用指定长度的指定随机种子生成并返回掩码。</summary> /// <returns>长度等于 <paramref name="cbReturn" /> 参数的随机生成的掩码。</returns> /// <param name="rgbSeed">用于计算掩码的随机种子。</param> /// <param name="cbReturn">生成的掩码的长度(以字节为单位)。</param> public override byte[] GenerateMask(byte[] rgbSeed, int cbReturn) { HashAlgorithm hashAlgorithm = (HashAlgorithm)CryptoConfig.CreateFromName(this.HashNameValue); byte[] counter = new byte[4]; byte[] numArray = new byte[cbReturn]; uint num = 0; int dstOffset = 0; while (dstOffset < numArray.Length) { Utils.ConvertIntToByteArray(num++, ref counter); hashAlgorithm.TransformBlock(rgbSeed, 0, rgbSeed.Length, rgbSeed, 0); hashAlgorithm.TransformFinalBlock(counter, 0, 4); byte[] hash = hashAlgorithm.Hash; hashAlgorithm.Initialize(); if (numArray.Length - dstOffset > hash.Length) { Buffer.BlockCopy((Array)hash, 0, (Array)numArray, dstOffset, hash.Length); } else { Buffer.BlockCopy((Array)hash, 0, (Array)numArray, dstOffset, numArray.Length - dstOffset); } dstOffset += hashAlgorithm.Hash.Length; } return(numArray); }
public override byte[] GenerateMask(byte[] rgbSeed, int cbReturn) { using (HashAlgorithm hasher = CryptoConfig.CreateFromName(_hashNameValue) as HashAlgorithm) { if (hasher is null) { throw new CryptographicException(SR.Format(SR.Cryptography_UnknownHashAlgorithm, _hashNameValue)); } byte[] rgbCounter = new byte[4]; byte[] rgbT = new byte[cbReturn]; uint counter = 0; for (int ib = 0; ib < rgbT.Length;) { // Increment counter -- up to 2^32 * sizeof(Hash) Helpers.ConvertIntToByteArray(counter++, rgbCounter); hasher.TransformBlock(rgbSeed, 0, rgbSeed.Length, rgbSeed, 0); hasher.TransformFinalBlock(rgbCounter, 0, 4); byte[] hash = hasher.Hash; hasher.Initialize(); Buffer.BlockCopy(hash, 0, rgbT, ib, Math.Min(rgbT.Length - ib, hash.Length)); ib += hasher.Hash.Length; } return(rgbT); } }
public static string Hash(Stream input, HashAlgorithm algorithm) { System.Security.Cryptography.HashAlgorithm hasher = GetAlgorithm(algorithm); byte[] buffer = new byte[StreamBufferSize]; int read; long currentPosition = 0L; long streamLength = input.Length; while ((read = input.Read(buffer, 0, buffer.Length)) > 0) { currentPosition += read; #pragma warning disable IDE0045 // Convert to conditional expression if (currentPosition < streamLength) { _ = hasher.TransformBlock(buffer, 0, read, buffer, 0); } else { _ = hasher.TransformFinalBlock(buffer, 0, read); } #pragma warning restore IDE0045 // Convert to conditional expression } byte[] hashBytes = hasher.Hash; string hastStr = hashBytes.ToHex(); return(hastStr); }
public override byte[] GenerateMask(byte[] rgbSeed, int cbReturn) { HashAlgorithm algorithm = (HashAlgorithm)CryptoConfig.CreateFromName(this.HashNameValue); byte[] counter = new byte[4]; byte[] dst = new byte[cbReturn]; uint num = 0; for (int i = 0; i < dst.Length; i += algorithm.Hash.Length) { Utils.ConvertIntToByteArray(num++, ref counter); algorithm.TransformBlock(rgbSeed, 0, rgbSeed.Length, rgbSeed, 0); algorithm.TransformFinalBlock(counter, 0, 4); byte[] hash = algorithm.Hash; algorithm.Initialize(); if ((dst.Length - i) > hash.Length) { Buffer.BlockCopy(hash, 0, dst, i, hash.Length); } else { Buffer.BlockCopy(hash, 0, dst, i, dst.Length - i); } } return(dst); }
public void WriteHash(HashAlgorithm hash, DocPosition docPos, AncestralNamespaceContextManager anc) { if (this.IsInNodeSet) { byte[] bytes = new UTF8Encoding(false).GetBytes(System.Security.Cryptography.Xml.Utils.EscapeTextData(this.Value)); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); } }
protected override byte[] HashFinal() { if (m_hashing == false) { m_hash1.TransformBlock(m_inner, 0, m_inner.Length, m_inner, 0); m_hashing = true; } // finalize the original hash m_hash1.TransformFinalBlock(EmptyArray <Byte> .Value, 0, 0); byte[] hashValue1 = m_hash1.HashValue; // write the outer array m_hash2.TransformBlock(m_outer, 0, m_outer.Length, m_outer, 0); // write the inner hash and finalize the hash m_hash2.TransformBlock(hashValue1, 0, hashValue1.Length, hashValue1, 0); m_hashing = false; m_hash2.TransformFinalBlock(EmptyArray <Byte> .Value, 0, 0); return(m_hash2.HashValue); }
public void WriteHash(HashAlgorithm hash, DocPosition docPos, AncestralNamespaceContextManager anc) { if (IsInNodeSet) { UTF8Encoding utf8 = new UTF8Encoding(false); byte[] rgbData = utf8.GetBytes(Utils.EscapeTextData(Value)); hash.TransformBlock(rgbData, 0, rgbData.Length, rgbData, 0); } }
private byte[] ComputeBaseValue() { _hash.Initialize(); _hash.TransformBlock(_password, 0, _password.Length, _password, 0); if (_salt != null) { _hash.TransformBlock(_salt, 0, _salt.Length, _salt, 0); } _hash.TransformFinalBlock(EmptyArray <Byte> .Value, 0, 0); _baseValue = _hash.Hash; _hash.Initialize(); for (int i = 1; i < (_iterations - 1); i++) { _hash.ComputeHash(_baseValue); _baseValue = _hash.Hash; } return(_baseValue); }
private static void AddFileToHash(string filename, HashAlgorithm hashService, StreamFilter filter = null, Encoding encoding = null) { if (filter == null || filter == StreamFilter.None) { using (var stream = File.OpenRead(filename)) { var buffer = new byte[1200000]; var bytesRead = stream.Read(buffer, 0, buffer.Length); while (bytesRead > 1) { hashService.TransformBlock(buffer, 0, bytesRead, buffer, 0); bytesRead = stream.Read(buffer, 0, buffer.Length); } } } else { if (encoding == null) { if (Path.GetExtension(filename).Equals(".res", StringComparison.InvariantCultureIgnoreCase)) { encoding = Encoding.Unicode; } else { encoding = Encoding.Default; } } using (var stream = File.OpenRead(filename)) { using (var reader = new StreamReader(stream, encoding)) { foreach (var line in filter.ReadAllLines(reader)) { var lineBuffer = encoding.GetBytes(line); hashService.TransformBlock(lineBuffer, 0, lineBuffer.Length, lineBuffer, 0); } } } } }
public void FIPS186_e(string testName, HashAlgorithm hash, byte[] input, byte[] result) { byte[] copy = new byte [input.Length]; for (int i=0; i < input.Length - 1; i++) hash.TransformBlock (input, i, 1, copy, i); hash.TransformFinalBlock (input, input.Length - 1, 1); // LAMESPEC or FIXME: TransformFinalBlock doesn't return HashValue ! // AssertEquals (testName + ".e.1", result, output); Assert.AreEqual (result, hash.Hash, testName + ".e"); // required or next operation will still return old hash hash.Initialize (); }
public void WriteHash(HashAlgorithm hash, DocPosition docPos, AncestralNamespaceContextManager anc) { if (this.IsInNodeSet) { byte[] bytes; UTF8Encoding encoding = new UTF8Encoding(false); if (docPos == DocPosition.AfterRootElement) { bytes = encoding.GetBytes("(char) 10"); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); } bytes = encoding.GetBytes("<?"); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); bytes = encoding.GetBytes(this.Name); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); if ((this.Value != null) && (this.Value.Length > 0)) { bytes = encoding.GetBytes(" " + this.Value); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); } bytes = encoding.GetBytes("?>"); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); if (docPos == DocPosition.BeforeRootElement) { bytes = encoding.GetBytes("(char) 10"); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); } } }
public HashTransformer(StateHash hash) { mHash = hash; if (hash == null) return; mHasher = new SHA256Cng(); var bytes = mHash.GetBytes(); mHasher.TransformBlock(bytes, 0, bytes.Length, null, 0); mCryptoStream = new CryptoStream(new FakeStream(), mHasher, CryptoStreamMode.Write); }
/// <summary> /// Prepares to resume. /// </summary> /// <param name="successfulLength">Successful length.</param> /// <param name="successfulPart">Successful part.</param> /// <param name="hashAlg">Hash algorithm</param> public static void PrepareResume(long successfulLength, Stream successfulPart, HashAlgorithm hashAlg) { byte[] buffer = new byte[4096]; int pos = 0; while (pos < successfulLength) { int l = successfulPart.Read(buffer, 0, (int)Math.Min(buffer.Length, successfulLength - pos)); if (l <= 0) { throw new IOException(string.Format("File stream is shorter ({0}) than the given length {1}", pos, successfulLength)); } hashAlg.TransformBlock(buffer, 0, l, buffer, 0); pos += l; } }
public void WriteHash(HashAlgorithm hash, DocPosition docPos, AncestralNamespaceContextManager anc) { if (this.IsInNodeSet && this.IncludeComments) { UTF8Encoding encoding = new UTF8Encoding(false); byte[] bytes = encoding.GetBytes("(char) 10"); if (docPos == DocPosition.AfterRootElement) { hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); } bytes = encoding.GetBytes("<!--"); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); bytes = encoding.GetBytes(this.Value); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); bytes = encoding.GetBytes("-->"); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); if (docPos == DocPosition.BeforeRootElement) { bytes = encoding.GetBytes("(char) 10"); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); } } }
//---------------------------------------------------------------------------------- protected override byte[] HashFinal() { if (!_bhashing) { _h1.TransformBlock(_binner, 0, _blocksize, _binner, 0); _bhashing = true; } _h1.TransformFinalBlock(new byte[0], 0, 0); _h2.TransformBlock(_bouter, 0, _blocksize, _bouter, 0); _h2.TransformFinalBlock(_h1.Hash, 0, _h1.Hash.Length); _bhashing = false; return(_h2.Hash); }
public byte[] ComputeHash(FileStream fileStream, HashAlgorithm hashAlgorithm, byte[] buffer) { while (true) { int bytesRead = fileStream.Read(buffer, 0, buffer.Length); if (bytesRead == buffer.Length) { hashAlgorithm.TransformBlock(buffer, 0, bytesRead, buffer, 0); } else { hashAlgorithm.TransformFinalBlock(buffer, 0, bytesRead); return hashAlgorithm.Hash; } } }
/// <summary> /// Computes a file hash without loading the entire file into memory. /// </summary> /// <param name="filePath">Path of the file to hash.</param> /// <param name="hashAlgorithm">Algorithm to hash in. Example: 'new SHA1CryptoServiceProvider()'</param> /// <returns></returns> public static string ComputeHash(string filePath, HashAlgorithm hashAlgorithm) { try { using (var stream = (Stream)File.Open(filePath, FileMode.Open)) { int _bufferSize = 4096; // this makes it impossible to change the buffer size while computing byte[] readAheadBuffer, buffer; int readAheadBytesRead, bytesRead; long size, totalBytesRead = 0; size = stream.Length; readAheadBuffer = new byte[_bufferSize]; readAheadBytesRead = stream.Read(readAheadBuffer, 0, readAheadBuffer.Length); totalBytesRead += readAheadBytesRead; do { bytesRead = readAheadBytesRead; buffer = readAheadBuffer; readAheadBuffer = new byte[_bufferSize]; readAheadBytesRead = stream.Read(readAheadBuffer, 0, readAheadBuffer.Length); totalBytesRead += readAheadBytesRead; if (readAheadBytesRead == 0) hashAlgorithm.TransformFinalBlock(buffer, 0, bytesRead); else hashAlgorithm.TransformBlock(buffer, 0, bytesRead, buffer, 0); } while (readAheadBytesRead != 0); } string hex = ""; foreach (byte b in hashAlgorithm.Hash) hex += b.ToString("x2"); return hex.ToLower(); } catch (Exception) { return null; } }
public override void Reset() { state = 0; position = 0; hashnumber = 0; hash = HashAlgorithm.Create(HashNameValue); if (SaltValue != null) { hash.TransformBlock(password, 0, password.Length, password, 0); hash.TransformFinalBlock(SaltValue, 0, SaltValue.Length); initial = hash.Hash; } else { initial = hash.ComputeHash(password); } }
/// <summary>Process the last block of data.</summary> /// <param name="inputBuffer">The block of data to process.</param> /// <param name="inputOffset">Where to start in the block.</param> /// <param name="inputCount">How many bytes need to be processed.</param> /// <returns>The results of the completed hash calculation.</returns> override protected byte[] ProcessFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) { lock (syncLock) { if (inputCount > 0) { workingNodes.Add(new HashNode(hashAlgorithm.ComputeHash(inputBuffer, inputOffset, inputCount), Count, (Count + inputCount - 1))); } finalNodes = workingNodes; // Calculate the top hash. hashAlgorithm.Initialize(); foreach (HashNode node in this) { hashAlgorithm.TransformBlock(node.Hash, 0, node.Hash.Length, null, 0); } hashAlgorithm.TransformFinalBlock(new byte[1], 0, 0); return(hashAlgorithm.Hash); } }
/// <exception cref="IOException">The underlying stream is null or closed. </exception> /// <exception cref="DirectoryNotFoundException">The specified path is invalid, (for example, it is on an unmapped drive). </exception> /// <exception cref="UnauthorizedAccessException"><paramref name="path" /> specified a directory.-or- The caller does not have the required permission. </exception> /// <exception cref="FileNotFoundException">The file specified in <paramref name="path" /> was not found. </exception> /// <exception cref="CryptographicUnexpectedOperationException"><see cref="F:System.Security.Cryptography.HashAlgorithm.HashValue" /> is null. </exception> /// <exception cref="ObjectDisposedException">The object has already been disposed.</exception> /// <exception cref="ArgumentNullException"><paramref name="oldValue" /> is null. </exception> /// <exception cref="ArgumentException"><paramref name="oldValue" /> is the empty string (""). </exception> /// <exception cref="Exception">A delegate callback throws an exception.</exception> /// <exception cref="OperationCanceledException">The token has had cancellation requested.</exception> public string CalculateHash(string file, HashAlgorithm algorithm, CancellationToken token) { byte[] buffer; byte[] oldBuffer; int bytesRead; int oldBytesRead; long size; long totalBytesRead = 0; using (var bufferedStream = new BufferedStream(File.OpenRead(file))) { using (algorithm) { size = bufferedStream.Length; buffer = new byte[4096]; bytesRead = bufferedStream.Read(buffer, 0, buffer.Length); totalBytesRead += bytesRead; do { token.ThrowIfCancellationRequested(); oldBytesRead = bytesRead; oldBuffer = buffer; buffer = new byte[4096]; bytesRead = bufferedStream.Read(buffer, 0, buffer.Length); totalBytesRead += bytesRead; if (bytesRead == 0) { algorithm.TransformFinalBlock(oldBuffer, 0, oldBytesRead); } else { algorithm.TransformBlock(oldBuffer, 0, oldBytesRead, oldBuffer, 0); } HashProgressUpdate?.Invoke(this, new ProgressEventArgs((double) totalBytesRead*100/size)); } while (bytesRead != 0); return BitConverter.ToString(algorithm.Hash).Replace("-", string.Empty).ToUpper(); } } }
protected override byte[] HashFinal() { if (_disposed) { throw new ObjectDisposedException("HMAC"); } State = 0; Block.Final(); byte[] intermediate = _algo.Hash; byte[] buf = KeySetup(Key, 0x5C); _algo.Initialize(); _algo.TransformBlock(buf, 0, buf.Length, buf, 0); _algo.TransformFinalBlock(intermediate, 0, intermediate.Length); byte[] hash = _algo.Hash; _algo.Initialize(); // zeroize sensitive data Array.Clear(buf, 0, buf.Length); Array.Clear(intermediate, 0, intermediate.Length); return(hash); }
public override void Reset() { #if NET_2_0 state = 0; #else // note: Reset doesn't change state #endif position = 0; hashnumber = 0; hash = HashAlgorithm.Create(HashNameValue); if (SaltValue != null) { hash.TransformBlock(password, 0, password.Length, password, 0); hash.TransformFinalBlock(SaltValue, 0, SaltValue.Length); initial = hash.Hash; } else { initial = hash.ComputeHash(password); } }
public override byte[] GenerateMask(byte[] rgbSeed, int cbReturn) { using (HashAlgorithm hasher = SHA1.Create()) { byte[] rgbCounter = new byte[4]; byte[] rgbT = new byte[cbReturn]; uint counter = 0; for (int ib = 0; ib < rgbT.Length;) { // Increment counter -- up to 2^32 * sizeof(Hash) Helpers.ConvertIntToByteArray(counter++, rgbCounter); hasher.TransformBlock(rgbSeed, 0, rgbSeed.Length, rgbSeed, 0); hasher.TransformFinalBlock(rgbCounter, 0, 4); byte[] hash = hasher.Hash; hasher.Initialize(); Buffer.BlockCopy(hash, 0, rgbT, ib, Math.Min(rgbT.Length - ib, hash.Length)); ib += hasher.Hash.Length; } return(rgbT); } }
public static bool TestMultiBlock(HashAlgorithm hash, byte[] data, byte[] digest) { int pos = 0; hash.Initialize(); while (data.Length - pos >= 1) pos += hash.TransformBlock(data, pos, 1, data, pos); hash.TransformFinalBlock(data, pos, data.Length - pos); if (!CompareBytes(hash.Hash, digest)) { Log.Comment("MultiBlock test failed"); return false; } return true; }
private void HashString(HashAlgorithm hasher, string hashThis) { var bytes = Encoding.UTF8.GetBytes(hashThis); hasher.TransformBlock(bytes, 0, bytes.Length, null, 0); }
/// <summary> /// Calculates an ongoing hash. /// </summary> /// <param name="input">The data to calculate the hash on.</param> /// <param name="offset">The offset in the input buffer to calculate from.</param> /// <param name="count">The number of bytes to use from input.</param> /// <param name="hash">The hash algorithm to use.</param> internal static void ComputeHash(byte[] input, int offset, int count, HashAlgorithm hash) { hash.TransformBlock(input, offset, count, null, 0); }
public override void Reset () { state = 0; position = 0; hashnumber = 0; hash = HashAlgorithm.Create (HashNameValue); if (SaltValue != null) { hash.TransformBlock (password, 0, password.Length, password, 0); hash.TransformFinalBlock (SaltValue, 0, SaltValue.Length); initial = hash.Hash; } else initial = hash.ComputeHash (password); }
private static void ComputeMore(HashAlgorithm hasher, int data) { // TODO: make this thread local to save the byte array allocation. byte[] bytes = BitConverter.GetBytes(data); hasher.TransformBlock(bytes, 0, bytes.Length, bytes, 0); }
private void HashIsHidden(HashAlgorithm hasher, bool isHidden) { var bytes = new[] {isHidden ? (byte) 1 : (byte) 0}; hasher.TransformBlock(bytes, 0, bytes.Length, null, 0); }
public (SM2DeriveBytes?Key, byte[] Verifier, byte[] PeerVerifier) DeriveKey( EcPoint peerPubKey, EcPoint peerR, ReadOnlySpan <byte> peerIdent) { if (!_ephemeralKey.Param.Curve.ValidatePoint(peerPubKey)) { throw new CryptographicException(); } if (!_ephemeralKey.Param.Curve.ValidatePoint(peerR)) { throw new CryptographicException(); } var pkBytes = (_ephemeralKey.Param.Curve.BitLength + 7) / 8; var zPeer = SM2.ZValue(_ephemeralKey.Param, _hash, peerIdent, peerPubKey); var w = _ephemeralKey.Param.BitLength; if (_ephemeralKey.Param.N.IsPowerOfTwo) { w -= 1; } w = (ushort)((w >> 1) + (w & 1) - 1); var w2 = (BigInteger)1 << w; var x2 = w2 + (_ephemeralKey.Q.X & (w2 - 1)); var t = (_privateKey + x2 * _ephemeralKey.D) % _ephemeralKey.Param.N; var x1 = w2 + (peerR.X & (w2 - 1)); var vi = _ephemeralKey.Param.Curve.MultiplyAndAdd(1, peerPubKey, x1, peerR, _rng); var v = _ephemeralKey.Param.Curve.ToAffine(_ephemeralKey.Param.Curve.Multiply(_ephemeralKey.Param.H * t, vi, _rng)); if (v.Inf) { return(null, null !, null !); } var za = _responder ? zPeer : _zValue; var zb = _responder ? _zValue : zPeer; var zl = za.Length + zb.Length; var key = new byte[pkBytes * 2 + zl]; var xv = v.X.ToByteArrayUBe(pkBytes); var yv = v.Y.ToByteArrayUBe(pkBytes); xv.CopyTo(key, 0); yv.CopyTo(key, pkBytes); za.CopyTo(key, pkBytes * 2); zb.CopyTo(key, pkBytes * 2 + za.Length); var kdf = new SM2DeriveBytes(key, _hash); var ra = _responder ? peerR : _ephemeralKey.Q; var rb = _responder ? _ephemeralKey.Q : peerR; #if NETSTANDARD2_0 || NETSTANDARD2_1 _hash.Initialize(); _hash.TransformBlock(xv, 0, pkBytes, null, 0); _hash.TransformBlock(za, 0, za.Length, null, 0); _hash.TransformBlock(zb, 0, zb.Length, null, 0); _hash.TransformBlock(ra.X.ToByteArrayUBe(pkBytes), 0, pkBytes, null, 0); _hash.TransformBlock(ra.Y.ToByteArrayUBe(pkBytes), 0, pkBytes, null, 0); _hash.TransformBlock(rb.X.ToByteArrayUBe(pkBytes), 0, pkBytes, null, 0); _hash.TransformFinalBlock(rb.Y.ToByteArrayUBe(pkBytes), 0, pkBytes); var si = _hash.Hash; _hash.Initialize(); key[0] = 2; _hash.TransformBlock(key, 0, 1, null, 0); _hash.TransformBlock(yv, 0, pkBytes, null, 0); _hash.TransformFinalBlock(si, 0, si.Length); var sb = _hash.Hash; _hash.Initialize(); key[0] = 3; _hash.TransformBlock(key, 0, 1, null, 0); _hash.TransformBlock(yv, 0, pkBytes, null, 0); _hash.TransformFinalBlock(si, 0, si.Length); var sa = _hash.Hash; #else var sib = ArrayPool <byte> .Shared.Rent(pkBytes * 5 + zl); xv.CopyTo(sib, 0); za.CopyTo(sib, pkBytes); zb.CopyTo(sib, pkBytes + za.Length); ra.X.ToByteArrayUBe(pkBytes).CopyTo(sib, zl + pkBytes); ra.Y.ToByteArrayUBe(pkBytes).CopyTo(sib, zl + pkBytes * 2); rb.X.ToByteArrayUBe(pkBytes).CopyTo(sib, zl + pkBytes * 3); rb.Y.ToByteArrayUBe(pkBytes).CopyTo(sib, zl + pkBytes * 4); var si = _hash.ComputeHash(sib, 0, pkBytes * 5 + zl); ArrayPool <byte> .Shared.Return(sib); var sbb = ArrayPool <byte> .Shared.Rent(pkBytes + si.Length + 1); yv.CopyTo(sbb, 1); si.CopyTo(sbb, pkBytes + 1); sbb[0] = 2; var sb = _hash.ComputeHash(sbb, 0, pkBytes + si.Length + 1); sbb[0] = 3; var sa = _hash.ComputeHash(sbb, 0, pkBytes + si.Length + 1); ArrayPool <byte> .Shared.Return(sbb); #endif return(kdf, _responder ? sb : sa, _responder ? sa : sb); }
public override void Reset () { #if NET_2_0 state = 0; #else // note: Reset doesn't change state #endif position = 0; hashnumber = 0; hash = HashAlgorithm.Create (HashNameValue); if (SaltValue != null) { hash.TransformBlock (password, 0, password.Length, password, 0); hash.TransformFinalBlock (SaltValue, 0, SaltValue.Length); initial = hash.Hash; } else initial = hash.ComputeHash (password); }
private int DownloadNextChunk(IDocument remoteDocument, long offset, long remainingBytes, Transmission transmission, Stream outputstream, HashAlgorithm hashAlg) { lock(this.disposeLock) { if (this.disposed) { transmission.Status = TransmissionStatus.ABORTED; throw new ObjectDisposedException(transmission.Path); } IContentStream contentStream = remoteDocument.GetContentStream(remoteDocument.ContentStreamId, offset, remainingBytes); transmission.Length = remoteDocument.ContentStreamLength; transmission.Position = offset; using (var remoteStream = contentStream.Stream) using (var forwardstream = new ForwardReadingStream(remoteStream)) using (var offsetstream = new OffsetStream(forwardstream, offset)) using (var progress = transmission.CreateStream(offsetstream)) { byte[] buffer = new byte[8 * 1024]; int result = 0; int len; while ((len = progress.Read(buffer, 0, buffer.Length)) > 0) { outputstream.Write(buffer, 0, len); hashAlg.TransformBlock(buffer, 0, len, buffer, 0); result += len; outputstream.Flush(); } return result; } } }
private static void ComputeMore( HashAlgorithm hasher, byte[] code, int startIndex, Instruction instruction) { if (instruction == null) throw new ArgumentNullException("instruction"); // Find the opcode part. // TODO: in X86Codec, since a fixable location always comes after // prefix+opcode+modrm+sib, we should put the fixable location as // a property of the instruction instead of the operand. int opcodeLength = instruction.EncodedLength; foreach (Operand operand in instruction.Operands) { if (operand.FixableLocation.Length > 0) opcodeLength = Math.Min(opcodeLength, operand.FixableLocation.StartOffset); } // Since the opcode uniquely determines the displacement and // immediate format, we only need to hash the opcode part and // don't need to hash dummy zeros for the remaining part of the // instruction. hasher.TransformBlock(code, startIndex, opcodeLength, code, startIndex); }
private void HashDateTime(HashAlgorithm hasher, DateTime dateTime) { var bytes = BitConverter.GetBytes(dateTime.ToBinary()); hasher.TransformBlock(bytes, 0, bytes.Length, null, 0); }
/// <summary> /// Compute a hash of the bytes of the buffer within the frames of the given NetMQMessage. /// </summary> /// <param name="hash">the hashing-algorithm to employ</param> /// <param name="message">the NetMQMessage whose frames are to be hashed</param> private void Hash(HashAlgorithm hash, NetMQMessage message) { foreach (var frame in message) { // Access the byte-array that is the frame's buffer. byte[] bytes = frame.ToByteArray(true); // Compute the hash value for the region of the input byte-array (bytes), starting at index 0, // and copy the resulting hash value back into the same byte-array. hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); } }
private void Hash(HashAlgorithm hash, NetMQMessage message) { foreach (NetMQFrame frame in message) { byte[] bytes = frame.ToByteArray(true); hash.TransformBlock(bytes, 0, bytes.Length, bytes, 0); } }
void AddToDigest(HashAlgorithm algorithm, byte[] buffer, int offset, int count) { algorithm.TransformBlock(buffer, offset, count, buffer, offset); }
/// <summary> /// Downloads the file and returns the SHA-1 hash of the content of the saved file /// </summary> /// <param name="remoteDocument">Remote document.</param> /// <param name="localFileStream">Local taget file stream.</param> /// <param name="transmission">Transmission status.</param> /// <param name="hashAlg">Hash algoritm, which should be used to calculate hash of the uploaded stream content</param> /// <exception cref="IOException">On any disc or network io exception</exception> /// <exception cref="DisposeException">If the remote object has been disposed before the dowload is finished</exception> /// <exception cref="AbortException">If download is aborted</exception> /// <exception cref="CmisException">On exceptions thrown by the CMIS Server/Client</exception> public void DownloadFile( IDocument remoteDocument, Stream localFileStream, Transmission transmission, HashAlgorithm hashAlg, UpdateChecksum update = null) { byte[] buffer = new byte[8 * 1024]; int len; if (localFileStream.Length > 0) { localFileStream.Seek(0, SeekOrigin.Begin); while ((len = localFileStream.Read(buffer, 0, buffer.Length)) > 0) { hashAlg.TransformBlock(buffer, 0, len, buffer, 0); } } long offset = localFileStream.Position; long? fileLength = remoteDocument.ContentStreamLength; if (fileLength <= offset) { transmission.Length = fileLength.GetValueOrDefault(); transmission.Position = offset; hashAlg.TransformFinalBlock(new byte[0], 0, 0); return; } DotCMIS.Data.IContentStream contentStream = null; if (offset > 0) { long remainingBytes = (long)fileLength - offset; transmission.Length = remoteDocument.ContentStreamLength; transmission.Position = offset; contentStream = remoteDocument.GetContentStream(remoteDocument.ContentStreamId, offset, remainingBytes); } else { contentStream = remoteDocument.GetContentStream(); } using (var transmissionStream = transmission.CreateStream(localFileStream)) using (CryptoStream hashstream = new CryptoStream(transmissionStream, hashAlg, CryptoStreamMode.Write)) using (Stream remoteStream = contentStream != null ? contentStream.Stream : new MemoryStream(0)) { transmission.Length = remoteDocument.ContentStreamLength; transmission.Position = offset; int written = 0; while ((len = remoteStream.Read(buffer, 0, buffer.Length)) > 0) { lock (this.disposeLock) { if (this.disposed) { transmission.Status = TransmissionStatus.ABORTED; throw new ObjectDisposedException(transmission.Path); } try { hashstream.Write(buffer, 0, len); hashstream.Flush(); written += len; } catch (Exception) { this.UpdateHash(hashAlg, localFileStream.Length, update); throw; } if (written >= 1024 * 1024) { this.UpdateHash(hashAlg, localFileStream.Length, update); written = 0; } } } if (written > 0) { this.UpdateHash(hashAlg, localFileStream.Length, update); } } }
internal byte[] GetHash (HashAlgorithm hash) { if (blockNo < 1) ReadFirstBlock (); fs.Position = blockLength; // hash the rest of the file long n; int addsize = 0; // minus any authenticode signature (with 8 bytes header) if (dirSecurityOffset > 0) { // it is also possible that the signature block // starts within the block in memory (small EXE) if (dirSecurityOffset < blockLength) { blockLength = dirSecurityOffset; n = 0; } else { n = dirSecurityOffset - blockLength; } } else if (coffSymbolTableOffset > 0) { fileblock[PEOffset + 12] = 0; fileblock[PEOffset + 13] = 0; fileblock[PEOffset + 14] = 0; fileblock[PEOffset + 15] = 0; fileblock[PEOffset + 16] = 0; fileblock[PEOffset + 17] = 0; fileblock[PEOffset + 18] = 0; fileblock[PEOffset + 19] = 0; // it is also possible that the signature block // starts within the block in memory (small EXE) if (coffSymbolTableOffset < blockLength) { blockLength = coffSymbolTableOffset; n = 0; } else { n = coffSymbolTableOffset - blockLength; } } else { addsize = (int) (fs.Length & 7); if (addsize > 0) addsize = 8 - addsize; n = fs.Length - blockLength; } // Authenticode(r) gymnastics // Hash from (generally) 0 to 215 (216 bytes) int pe = peOffset + 88; hash.TransformBlock (fileblock, 0, pe, fileblock, 0); // then skip 4 for checksum pe += 4; // Continue hashing from (generally) 220 to 279 (60 bytes) hash.TransformBlock (fileblock, pe, 60, fileblock, pe); // then skip 8 bytes for IMAGE_DIRECTORY_ENTRY_SECURITY pe += 68; // everything is present so start the hashing if (n == 0) { // hash the (only) block hash.TransformFinalBlock (fileblock, pe, blockLength - pe); } else { // hash the last part of the first (already in memory) block hash.TransformBlock (fileblock, pe, blockLength - pe, fileblock, pe); // hash by blocks of 4096 bytes long blocks = (n >> 12); int remainder = (int)(n - (blocks << 12)); if (remainder == 0) { blocks--; remainder = 4096; } // blocks while (blocks-- > 0) { fs.Read (fileblock, 0, fileblock.Length); hash.TransformBlock (fileblock, 0, fileblock.Length, fileblock, 0); } // remainder if (fs.Read (fileblock, 0, remainder) != remainder) return null; if (addsize > 0) { hash.TransformBlock (fileblock, 0, remainder, fileblock, 0); hash.TransformFinalBlock (new byte [addsize], 0, addsize); } else { hash.TransformFinalBlock (fileblock, 0, remainder); } } return hash.Hash; }
/// <summary> /// Downloads the file and returns the SHA-1 hash of the content of the saved file /// </summary> /// <param name="remoteDocument">Remote document.</param> /// <param name="localFileStream">Local taget file stream.</param> /// <param name="transmission">Transmission status.</param> /// <param name="hashAlg">Hash algoritm, which should be used to calculate hash of the uploaded stream content</param> /// <param name="update">Not or not yet used</param> /// <exception cref="IOException">On any disc or network io exception</exception> /// <exception cref="DisposeException">If the remote object has been disposed before the dowload is finished</exception> /// <exception cref="AbortException">If download is aborted</exception> /// <exception cref="CmisException">On exceptions thrown by the CMIS Server/Client</exception> public void DownloadFile( IDocument remoteDocument, Stream localFileStream, Transmission transmission, HashAlgorithm hashAlg, UpdateChecksum update = null) { { byte[] buffer = new byte[8 * 1024]; int len; while ((len = localFileStream.Read(buffer, 0, buffer.Length)) > 0) { hashAlg.TransformBlock(buffer, 0, len, buffer, 0); } } long? fileLength = remoteDocument.ContentStreamLength; // Download content if exists if (fileLength > 0) { long offset = localFileStream.Position; long remainingBytes = (fileLength != null) ? (long)fileLength - offset : this.ChunkSize; try { do { offset += this.DownloadNextChunk(remoteDocument, offset, remainingBytes, transmission, localFileStream, hashAlg); } while(fileLength == null); } catch (DotCMIS.Exceptions.CmisConstraintException) { } } else { transmission.Position = 0; transmission.Length = 0; } hashAlg.TransformFinalBlock(new byte[0], 0, 0); }