Merge branch 'copilot/fix-34'

Author: Bas Visscher

ESPTool/Communication/Communicator.cs

@@ -130,6 +130,18 @@ public async Task<int> ReadRawAsync(byte[] buffer, CancellationToken token)
             return await _serialPort.BaseStream.ReadAsync(buffer, 0, buffer.Length, token);
         }
 
+        /// <summary>
+        /// Writes raw data asynchronously to the serial port.
+        /// </summary>
+        /// <param name="data">The data to write.</param>
+        /// <param name="token">Cancellation token to cancel the operation.</param>
+        /// <returns>A task representing the asynchronous operation.</returns>
+        /// <exception cref="OperationCanceledException">Thrown if the operation is canceled via the cancellation token.</exception>
+        public async Task WriteAsync(byte[] data, CancellationToken token)
+        {
+            await _serialPort.BaseStream.WriteAsync(data, 0, data.Length, token);
+        }
+
 
         /// <summary>
         /// Disposes the serial port and associated resources.
@@ -142,5 +154,10 @@ public void Dispose()
             }
             _serialPort.Dispose();
         }
+
+        internal async Task FlushAsync(CancellationToken token)
+        {
+            await _serialPort.BaseStream.FlushAsync(token);
+        }
     }
 }

ESPTool/ESPToolbox.cs

@@ -90,6 +90,12 @@ public async Task<byte[]> ReadEfuseAsync(ILoader loader, ChipTypes chipType, EFl
             return await tool.ReadAsync(key, token);
         }
 
+        public ReadFlashTool CreateReadFlashTool(Communicator communicator, SoftLoader softLoader, ChipTypes chipType)
+        {
+            var deviceConfig = GetDeviceConfig(chipType);
+            return new ReadFlashTool(softLoader, communicator);
+        }
+
         public IUploadTool CreateUploadRamTool(ILoader loader, ChipTypes chipType)
         {
             return new UploadRamTool(loader)

ESPTool/Example.cs

@@ -1,9 +1,6 @@
 using EspDotNet.Commands;
 using EspDotNet.Communication;
-using EspDotNet.Loaders;
-using System;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Diagnostics;
 
 namespace EspDotNet.Loaders.SoftLoader
 {
@@ -60,6 +57,29 @@ public async Task<byte[]> SPI_FLASH_MD5(uint address, uint size, CancellationTok
             return response.Payload.Take(16).ToArray(); // Return the MD5 checksum (first 16 bytes)
         }
 
+        public async Task FlashReadBeginAsync(uint address, uint size, uint blockSize, uint inflight, CancellationToken token)
+        {
+            var request = new RequestCommandBuilder()
+                .WithCommand(0xD2)
+                .AppendPayload(BitConverter.GetBytes(address))
+                .AppendPayload(BitConverter.GetBytes(size))
+                .AppendPayload(BitConverter.GetBytes(blockSize))
+                .AppendPayload(BitConverter.GetBytes(inflight))
+                .Build();
+
+
+            var response = await _commandExecutor.ExecuteCommandAsync(request, token);
+            if (!response.Success)
+                throw new InvalidOperationException("Failed to begin flash read.");
+        }
+
+        public async Task FlashReadAckAsync(uint totalBytesReceived, CancellationToken token)
+        {
+            var ackData = BitConverter.GetBytes(totalBytesReceived);
+            await _communicator.WriteFrameAsync(new Frame(ackData), token);
+            await _communicator.FlushAsync(token);
+        }
+
         /// <summary>
         /// Begins the flash process using compressed data.
         /// </summary>

ESPTool/Loaders/SoftLoader/SoftLoader.cs

@@ -0,0 +1,143 @@
+using EspDotNet.Communication;
+using EspDotNet.Loaders.SoftLoader;
+using System.Security.Cryptography;
+
+namespace EspDotNet.Tools
+{
+    public class ReadFlashTool
+    {
+        public IProgress<float> Progress { get; set; } = new Progress<float>();
+        public uint SectorSize { get; set; } = 4096;
+        public uint BlockSize { get; set; } = 4096;
+        public uint MaxInFlight { get; set; } = 1;
+
+        private readonly SoftLoader _softLoader;
+        private readonly Communicator _communicator;
+
+        public ReadFlashTool(SoftLoader softLoader, Communicator communicator)
+        {
+            _softLoader = softLoader;
+            _communicator = communicator;
+        }
+
+        /// <summary>
+        /// A wrapper stream that computes MD5 hash while writing to the underlying stream.
+        /// </summary>
+        private class MD5Stream : Stream
+        {
+            private readonly Stream _baseStream;
+            private readonly MD5 _md5;
+
+            public MD5Stream(Stream baseStream)
+            {
+                _baseStream = baseStream;
+                _md5 = MD5.Create();
+            }
+
+            public byte[] FinalizeAndGetHash()
+            {
+                _md5.TransformFinalBlock(Array.Empty<byte>(), 0, 0);
+                return _md5.Hash ?? throw new InvalidOperationException("Hash not computed yet.");
+            }
+
+            public override bool CanRead => false;
+            public override bool CanSeek => false;
+            public override bool CanWrite => _baseStream.CanWrite;
+            public override long Length => _baseStream.Length;
+            public override long Position { get => _baseStream.Position; set => _baseStream.Position = value; }
+
+            public override void Flush() => _baseStream.Flush();
+
+            public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+
+            public override long Seek(long offset, SeekOrigin origin) => _baseStream.Seek(offset, origin);
+
+            public override void SetLength(long value) => _baseStream.SetLength(value);
+
+            public override void Write(byte[] buffer, int offset, int count)
+            {
+                _md5.TransformBlock(buffer, offset, count, null, 0);
+                _baseStream.Write(buffer, offset, count);
+            }
+
+            public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+            {
+                _md5.TransformBlock(buffer, offset, count, null, 0);
+                await _baseStream.WriteAsync(buffer, offset, count, cancellationToken);
+            }
+
+            protected override void Dispose(bool disposing)
+            {
+                _md5.Dispose();
+                base.Dispose(disposing);
+            }
+        }
+
+
+        public async Task ReadFlashAsync(uint address, uint size, Stream outputStream, CancellationToken token)
+        {
+            if (outputStream == null)
+                throw new ArgumentNullException(nameof(outputStream));
+            if (!outputStream.CanWrite)
+                throw new ArgumentException("Output stream must be writable.", nameof(outputStream));
+
+            using var md5Stream = new MD5Stream(outputStream);
+
+            await _softLoader.FlashReadBeginAsync(address, size, BlockSize, MaxInFlight, token);
+
+            uint totalReceived = 0;
+
+            while (totalReceived < size)
+            {
+                totalReceived += await ReadFlashBlockAsync(md5Stream, totalReceived, token);
+                Progress.Report((float)totalReceived / size);
+            }
+
+            await VerifyMd5Async(address, size, md5Stream, token);
+        }
+
+        private async Task<uint> ReadFlashBlockAsync(MD5Stream md5Stream, uint totalReceived, CancellationToken token)
+        {
+            var frame = await _communicator.ReadFrameAsync(token);
+            if (frame?.Data == null)
+                throw new InvalidOperationException("Failed to receive flash data frame.");
+
+            await md5Stream.WriteAsync(frame.Data, 0, frame.Data.Length, token);
+
+            await _softLoader.FlashReadAckAsync(totalReceived + (uint)frame.Data.Length, token);
+
+            return (uint)frame.Data.Length;
+        }
+
+
+
+
+
+
+
+        private async Task VerifyMd5Async(uint address, uint size, MD5Stream stream, CancellationToken token)
+        {
+            var hashFrame = await _communicator.ReadFrameAsync(token);
+            var computedHash = stream.FinalizeAndGetHash();
+            var expectedHash = hashFrame?.Data ?? throw new Exception("Expected hash frame");
+
+            for (int i = 0; i < 16; i++)
+            {
+                if (computedHash[i] != expectedHash[i])
+                {
+                    var expected = BitConverter.ToString(expectedHash).Replace("-", "");
+                    var computed = BitConverter.ToString(computedHash).Replace("-", "");
+                    throw new InvalidOperationException(
+                        $"MD5 verification failed: expected {expected}, got {computed}");
+                }
+            }
+        }
+
+
+
+
+
+
+
+    }
+}