Merge pull request #1684 from Mr-Rm/v2/fix-1683

fix #1683: инкрементальное ХешированиеДанных без захвата файлов

Author: EvilBeaver

src/OneScript.StandardLibrary/Hash/Crc32.cs

@@ -62,19 +62,38 @@ public override void Initialize()
 
         protected override void HashCore(byte[] array, int ibStart, int cbSize)
         {
-            for (var i = ibStart; i < cbSize - ibStart; i++)
+            for (var i = ibStart; i < ibStart + cbSize; i++)
                 _crc = (_crc >> 8) ^ table[array[i] ^ _crc & 0xff];
         }
 
         protected override byte[] HashFinal()
         {
             var result = BitConverter.GetBytes(~_crc);
-            if (BitConverter.IsLittleEndian)
-                Array.Reverse(result);
 
             HashValue = result;
             return result;
-        }
-
+        }
+
+        #region IncrementalHash
+        public void AppendData(byte[] array)
+        {
+            HashCore(array, 0, array.Length);
+        }
+
+        public void AppendData(byte[] array, int offset, int count)
+        {
+            HashCore(array, offset, count);
+        }
+
+        public byte[] GetCurrentHash()
+        {
+            return BitConverter.GetBytes(~_crc);
+        }
+
+        public UInt32 GetCurrentHashAsUInt32()
+        {
+            return ~_crc;
+        }
+        #endregion
     }
 }

src/OneScript.StandardLibrary/Hash/HashImpl.cs

@@ -5,156 +5,234 @@ This Source Code Form is subject to the terms of the
 at http://mozilla.org/MPL/2.0/.
 ----------------------------------------------------------*/
 
-using System;
-using System.IO;
-using System.Security.Cryptography;
-using System.Text;
 using OneScript.Contexts;
 using OneScript.Exceptions;
 using OneScript.StandardLibrary.Binary;
 using OneScript.Values;
 using ScriptEngine.Machine;
 using ScriptEngine.Machine.Contexts;
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
 
 namespace OneScript.StandardLibrary.Hash
-{
+{
+    /// <summary>
+    /// Реализует инкрементальный расчет хеш-суммы по добавленным данным.
+    /// Тип вычисляемого значения определяются типом хеш-функции.
+    /// </summary>
     [ContextClass("ХешированиеДанных", "DataHashing")]
     public class HashImpl : AutoContext<HashImpl>, IDisposable
-    {
-        private HashAlgorithm _provider;
-        private HashFunctionEnum _enumValue;
-        private CombinedStream _toCalculate=new CombinedStream();
-        private bool _calculated;
+    {
+        private const int BUFFER_SIZE = (1024 * 32);
+
+        private readonly Crc32 _crc32;
+        private readonly IncrementalHash _provider;
+        private readonly HashFunctionEnum _enumValue;
         private byte[] _hash;
 
-        public HashImpl(HashAlgorithm provider, HashFunctionEnum enumValue)
+        public HashImpl(IncrementalHash provider, HashFunctionEnum enumValue)
         {
             _provider = provider;
             _enumValue = enumValue;
-            _calculated = false;
-        }
-
-        public byte[] InternalHash
-        {
-            get
-            {
-                if (!_calculated)
-                {
-                    _hash = _provider.ComputeHash(_toCalculate);
-                    _calculated = true;
-                }
-                return _hash;
-            }
-        }
-
+            if (enumValue == HashFunctionEnum.CRC32)
+            {
+                _crc32 = new Crc32();
+            }
+            else ArgumentNullException.ThrowIfNull(provider);
+
+            AppendData(Array.Empty<byte>());
+        }
+
+        /// <summary>
+        /// Вид хеш-функции, определяющий способ вычисления хеш-суммы.
+        /// Только для чтения
+        /// </summary>
+        /// <value>Перечисление ХешФункция</value>
         [ContextProperty("ХешФункция", "HashFunction")]
-        public HashFunctionEnum Extension => _enumValue;
-
+        public HashFunctionEnum HashFunction => _enumValue;
+
+        /// <summary>
+        /// Текущее значение хеш-суммы. Только для чтения
+        /// </summary>
+        /// <value>Для хеш-функции CRC32 - Число, для остальных - ДвоичныеДанные
+        /// </value>
         [ContextProperty("ХешСумма", "HashSum")]
         public IValue Hash
         {
             get
             {
-                if (_provider is Crc32)
-                {
-                    var buffer = new byte[4];
-                    Array.Copy(InternalHash, buffer, 4);
-                    if (BitConverter.IsLittleEndian)
-                        Array.Reverse(buffer);
-                    var ret = BitConverter.ToUInt32(buffer, 0);
-                    return ValueFactory.Create((decimal)ret);
-                }
-                return new BinaryDataContext(InternalHash);
+                if (_crc32 != null)
+                   return ValueFactory.Create(_crc32.GetCurrentHashAsUInt32());
+                
+                return new BinaryDataContext(_hash);
             }
-        }
-
+        }
+
+        /// <summary>
+        /// Нестандартное расширение!
+        /// Строковое представление текущего значения хеш-суммы. Только для чтения
+        /// </summary>
+        /// <value>Для хеш-функции CRC32 - Число, для остальных - ДвоичныеДанные</value>
         [ContextProperty("ХешСуммаСтрокой", "HashSumOfString")]
         public string HashString
         {
             get
-            {
+            {
+                if (_crc32 != null)
+                    return _crc32.GetCurrentHashAsUInt32().ToString("X8");
+
                 var sb = new StringBuilder();
-                for (int i = 0; i < InternalHash.Length; i++)
-                    sb.Append(InternalHash[i].ToString("X2"));
+                for (int i = 0; i < _hash.Length; i++)
+                    sb.Append(_hash[i].ToString("X2"));
                 return sb.ToString();
             }
         }
 
+        private void AppendData(byte[] data)
+        {
+            AppendData(data, data.Length);
+        }
 
+        private void AppendData(byte[] data, int count)
+        {
+            if (_crc32 != null)
+            {
+                _crc32.AppendData(data,0,count);
+            }
+            else
+            {
+                _provider.AppendData(data,0,count);
+                _hash = _provider.GetCurrentHash();
+            }
+        }
+
+        private void AppendStream(Stream stream)
+        {
+            var buffer = new byte[BUFFER_SIZE];
+            while (true)
+            {
+                var read = stream.Read(buffer,0, BUFFER_SIZE);
+                if (read == 0)
+                    break;
+
+                AppendData(buffer, read);
+            }
+         }
+
+        private void AppendStream(Stream stream, int count)
+        {
+            if (count <= 0)
+            {
+                AppendStream(stream);
+                return;
+            }
+
+            int bufSize = Math.Min(BUFFER_SIZE, count);
+            var buffer = new byte[bufSize];
+            int toRead = count;
+            while (toRead > 0)
+            {
+                var read = stream.Read(buffer,0, Math.Min(toRead, bufSize));
+                if (read == 0)
+                    break;
+
+                AppendData(buffer, read);
+                toRead -= read;
+            }
+        }
+
+        /// <summary>
+        /// Добавляет данные и  обновляет хеш-сумму
+        /// </summary>
+        /// <param name="toAdd">Источник данных. Строка, ДвоичныеДанные или Поток</param>
+        /// <param name="count">Для источника данных типов Строка или ДвоичныеДанные - игнорируется.
+        /// Для источника данных типа Поток - Количество байтов, которые читаются из потока.
+        /// Если количество не задано, нулевое <b>или отрицательное</b>, то читаются все данные до конца потока.
+        /// </param>
         [ContextMethod("Добавить", "Append")]
-        public void Append(BslValue toAdd, uint count = 0)
+        public void Append(BslValue toAdd, BslValue count = null)
         {
             switch (toAdd)
             {
                 case BslStringValue s:
-                    AddStream(new MemoryStream(Encoding.UTF8.GetBytes((string)s)));
+                    AppendData(Encoding.UTF8.GetBytes((string)s));
                     break;
-                case BslObjectValue obj when obj is IStreamWrapper wrapper:
-                    var stream = wrapper.GetUnderlyingStream();
-                    var readByte = (int)Math.Min(count == 0 ? stream.Length : count, stream.Length - stream.Position);
-                    var buffer = new byte[readByte];
-                    stream.Read(buffer, 0, readByte);
-                    AddStream(new MemoryStream(buffer));
+                case BinaryDataContext binaryData:
+                    AppendStream(binaryData.GetStream());
                     break;
-                case BslObjectValue obj when obj is BinaryDataContext binaryData:
-                    AddStream(binaryData.GetStream());
+
+                case IStreamWrapper wrapper:
+                    var stream = wrapper.GetUnderlyingStream();
+                    if (count == null)
+                    {
+                        AppendStream(stream);
+                    }
+                    else
+                    {
+                        int cnt;
+                        try
+                        {
+                            cnt = (int)count;
+                        }
+                        catch
+                        {
+                            if (count is BslStringValue)
+                                throw RuntimeException.InvalidNthArgumentValue(2);
+                            else
+                                throw RuntimeException.InvalidNthArgumentType(2);
+                        }
+
+                        AppendStream(stream, cnt);
+                    }
                     break;
+
                 default:
-                    throw RuntimeException.InvalidArgumentType(nameof(toAdd));
+                    throw RuntimeException.InvalidNthArgumentType(1);
             }
         }
 
+        /// <summary>
+        /// Добавляет двоичные данные из файла и обновляет хеш-сумму
+        /// </summary>
+        /// <param name="path">Имя файла, из которого читаются данные. Тип: Строка</param>
         [ContextMethod("ДобавитьФайл", "AppendFile")]
         public void AppendFile(string path)
         {
             if (!File.Exists(path))
-                throw RuntimeException.InvalidArgumentType();
-            AddStream(new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite));
+                throw RuntimeException.InvalidArgumentType();
+
+            using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            AppendStream(stream);
         }
 
-        [ContextMethod("Очистить", "Clear")]
-        public void Clear()
-        {
-            _toCalculate.Close();
-            _toCalculate.Dispose();
-            _toCalculate = new CombinedStream();
-            _calculated = false;
-        }
-
-
         [ScriptConstructor(Name = "По указанной хеш-функции")]
         public static HashImpl Constructor(HashFunctionEnum providerEnum)
-        {
-            var objectProvider = GetProvider(providerEnum);
+        {
+            if (providerEnum == HashFunctionEnum.CRC32)
+                return new HashImpl(null, providerEnum);
+
+            var objectProvider = IncrementalHash.CreateHash(GetAlgorithmName(providerEnum));
             return new HashImpl(objectProvider, providerEnum);
         }
 
-        private static HashAlgorithm GetProvider(HashFunctionEnum algo)
+        private static HashAlgorithmName GetAlgorithmName(HashFunctionEnum algo)
         {
-            switch (algo)
-            {
-                case HashFunctionEnum.CRC32:
-                    return new Crc32();
-                default:
-                    var ret = HashAlgorithm.Create(algo.ToString());
-                    if (ret == null)
-                        throw RuntimeException.InvalidArgumentType();
-                    return ret;
-            }
-        }
-
+            return algo switch
+            {
+                HashFunctionEnum.MD5 => HashAlgorithmName.MD5,
+                HashFunctionEnum.SHA1 => HashAlgorithmName.SHA1,
+                HashFunctionEnum.SHA256 => HashAlgorithmName.SHA256,
+                HashFunctionEnum.SHA384 => HashAlgorithmName.SHA384,
+                HashFunctionEnum.SHA512 => HashAlgorithmName.SHA512,
+                _ => throw RuntimeException.InvalidArgumentValue()
+            };
+        }
+
         public void Dispose()
         {
-            _toCalculate.Close();
-            _toCalculate.Dispose();
-        }
-
-        private void AddStream(Stream stream)
-        {
-            _toCalculate.AddStream(stream);
-            _toCalculate.Seek(0, SeekOrigin.Begin);
-            _calculated = false;
-            
+            _provider?.Dispose();
         }
     }
 }