Add the additional check part to MiniKey to only report the correct key result instead of all of them

Author: Coding-Enthusiast

Src/FinderOuter/Services/MiniKeyService.cs

@@ -21,6 +21,7 @@ public class MiniKeyService
         public MiniKeyService(IReport rep)
         {
             inputService = new InputService();
+            comparer = new PrivateKeyToAddressComparer();
             report = rep;
         }
 
@@ -31,6 +32,7 @@ public MiniKeyService(IReport rep)
         private int[] missingIndexes;
         private int missCount;
         private string keyToCheck;
+        private ICompareService comparer;
 
 
         private BigInteger GetTotalCount(int missCount) => BigInteger.Pow(58, missCount);
@@ -46,29 +48,28 @@ private void SetResult(IEnumerable<byte> item)
                     temp[missingIndexes[i++]] = (char)index;
                 }
 
-                report.AddMessageSafe($"Found a possible result (still running): {new string(temp)}");
+                report.AddMessageSafe($"Found a possible result: {new string(temp)}");
                 return;
             });
         }
 
         private unsafe bool Loop23()
         {
-            // The actual data that is changing is 22 bytes (22 char long mini key)
-            // plus an additional byte added to the end (char(?)=0x3f).
+            // The actual data that is changing is 22 bytes (22 char long mini key) with a fixed starting character ('S')
+            // plus an additional byte added to the end (char('?')=0x3f) during checking loop.
             // Checksum is replaced by checking if first byte of hash result is zero.
+            // The actual key itself is the hash of the same 22 bytes (without '?') using a single SHA256
+            // Note characters are decoded using UTF-8
 
             var cartesian = CartesianProduct.Create(Enumerable.Repeat(Encoding.UTF8.GetBytes(ConstantsFO.Base58Chars), missCount));
             using Sha256 sha = new Sha256();
-            uint[] secondW = new uint[sha.w.Length];
             bool success = false;
 
             byte[] temp = new byte[precomputed.Length];
-            fixed (uint* hPt = &sha.hashState[0], wPt = &sha.w[0], w2Pt = &secondW[0])
+            fixed (uint* hPt = &sha.hashState[0], wPt = &sha.w[0])
             fixed (byte* pre = &precomputed[0], tmp = &temp[0])
             fixed (int* mi = &missingIndexes[0])
             {
-                wPt[15] = 184; // 23 *8 = 184
-
                 foreach (var item in cartesian)
                 {
                     Buffer.MemoryCopy(pre, tmp, 22, 22);
@@ -88,18 +89,28 @@ private unsafe bool Loop23()
                     // The added value below is the SHA padding and the last added ? char equal to 0x3f shifted right 8 places
                     wPt[5] = (uint)tmp[20] << 24 | (uint)tmp[21] << 16 | 0b00000000_00000000_00111111_10000000U;
                     // from 6 to 14 = 0
-                    // 15 is already set above
+                    wPt[15] = 184; // 23 *8 = 184
 
                     sha.Init(hPt);
                     sha.Compress23(hPt, wPt);
 
                     if ((hPt[0] & 0b11111111_00000000_00000000_00000000U) == 0)
                     {
-                        // TODO: perform another hash using the same wPt but change the char(?) value to SHA pad and
-                        // prev SHA pad to zero
-                        // this will give the actual 32 bytes key then perform the checks versus address,...
-                        SetResult(item);
-                        success = true;
+                        // The actual key is SHA256 of 22 char key (without '?')
+                        // SHA working vector is already set, only the last 2 bytes ('?' and pad) and the length have to change
+                        wPt[5] ^= 0b00000000_00000000_10111111_10000000U;
+                        // from 6 to 14 (remain) = 0
+                        wPt[15] = 176; // 22 *8 = 176
+
+                        sha.Init(hPt);
+                        sha.Compress22(hPt, wPt);
+
+                        if (comparer.Compare(sha.GetBytes(hPt)))
+                        {
+                            SetResult(item);
+                            success = true;
+                            break;
+                        }
                     }
                 }
             }
@@ -112,16 +123,13 @@ private unsafe bool Loop31()
         {
             var cartesian = CartesianProduct.Create(Enumerable.Repeat(Encoding.UTF8.GetBytes(ConstantsFO.Base58Chars), missCount));
             using Sha256 sha = new Sha256();
-            uint[] secondW = new uint[sha.w.Length];
             bool success = false;
 
             byte[] temp = new byte[precomputed.Length];
-            fixed (uint* hPt = &sha.hashState[0], wPt = &sha.w[0], w2Pt = &secondW[0])
+            fixed (uint* hPt = &sha.hashState[0], wPt = &sha.w[0])
             fixed (byte* pre = &precomputed[0], tmp = &temp[0])
             fixed (int* mi = &missingIndexes[0])
             {
-                wPt[15] = 248; // 31 *8 = 184
-
                 foreach (var item in cartesian)
                 {
                     Buffer.MemoryCopy(pre, tmp, 30, 30);
@@ -143,16 +151,27 @@ private unsafe bool Loop31()
                     // The added value below is the SHA padding and the last added ? char equal to 0x3f shifted right 8 places
                     wPt[7] = (uint)tmp[28] << 24 | (uint)tmp[29] << 16 | 0b00000000_00000000_00111111_10000000U;
                     // from 8 to 14 = 0
-                    // 15 is already set above
+                    wPt[15] = 248; // 31 *8 = 184
 
                     sha.Init(hPt);
                     sha.Compress31(hPt, wPt);
 
                     if ((hPt[0] & 0b11111111_00000000_00000000_00000000U) == 0)
                     {
-                        // TODO: same as above
-                        SetResult(item);
-                        success = true;
+                        // Same as above
+                        wPt[7] ^= 0b00000000_00000000_10111111_10000000U;
+                        // from 8 to 14 (remain) = 0
+                        wPt[15] = 240; // 30 *8 = 240
+
+                        sha.Init(hPt);
+                        sha.Compress30(hPt, wPt);
+
+                        if (comparer.Compare(sha.GetBytes(hPt)))
+                        {
+                            SetResult(item);
+                            success = true;
+                            break;
+                        }
                     }
                 }
             }
@@ -172,6 +191,11 @@ public async Task<bool> Find(string key, string extra, char missingChar)
             if (!key.StartsWith(ConstantsFO.MiniKeyStart))
                 return report.Fail($"Minikey must start with {ConstantsFO.MiniKeyStart}.");
 
+            if (!((PrivateKeyToAddressComparer)comparer).TrySetHash(extra))
+            {
+                return report.Fail("Invalid address.");
+            }
+
             missCount = key.Count(c => c == missingChar);
             if (missCount == 0)
             {

Src/FinderOuter/ViewModels/MissingMiniPrivateKeyViewModel.cs

@@ -18,9 +18,12 @@ public MissingMiniPrivateKeyViewModel()
             miniService = new MiniKeyService(Result);
 
             IObservable<bool> isFindEnabled = this.WhenAnyValue(
-                x => x.Input, x => x.MissingChar,
-                x => x.Result.CurrentState, (b58, c, state) =>
-                            !string.IsNullOrEmpty(b58) &&
+                x => x.Input,
+                x => x.ExtraInput,
+                x => x.MissingChar,
+                x => x.Result.CurrentState, (miniKey, addr, c, state) =>
+                            !string.IsNullOrEmpty(miniKey) &&
+                            !string.IsNullOrEmpty(addr) &&
                             inServ.IsMissingCharValid(c) &&
                             state != Models.State.Working);
 
@@ -29,7 +32,12 @@ public MissingMiniPrivateKeyViewModel()
 
         public override string OptionName => "Missing mini private key";
 
-        public override string Description => "This option can recover missing characters in a mini private key.";
+        public override string Description => 
+            $"This option can recover missing characters in a mini private key." +
+            $"{Environment.NewLine}" +
+            $"Enter the mini key (22 or 30 characters long starting with S) in first box while replacing its missing " +
+            $"characters with the specified {nameof(MissingChar)} and enter the " +
+            $"corresponding address in second box and click Find button.";
 
 
         private readonly MiniKeyService miniService;

Src/FinderOuter/Views/MissingMiniPrivateKeyView.xaml

@@ -10,7 +10,7 @@
   </Design.DataContext>
 
   <Grid ColumnDefinitions="*,auto" RowDefinitions="*,auto">
-    <TextBox Text="{Binding Input}" Watermark="Base-58 encoded string" UseFloatingWatermark="True"
+    <TextBox Text="{Binding Input}" Watermark="Mini-private-key (22 or 30 characters long)" UseFloatingWatermark="True"
              TextWrapping="Wrap"
              Margin="3" Grid.Column="0" Grid.Row="0"/>
 
@@ -20,14 +20,9 @@
                Height="38" Width="40" Margin="3"/>
     </StackPanel>
 
-    <TextBox Text="{Binding ExtraInput}" Watermark="Extra input to check against (Public key or address)"
+    <TextBox Text="{Binding ExtraInput}" Watermark="Extra input to check against (address)"
              UseFloatingWatermark="True"
              Margin="3" Grid.Column="0" Grid.Row="1"/>
 
-    <StackPanel Orientation="Vertical" Spacing="5" Margin="3" Grid.Column="1" Grid.Row="1">
-      <TextBlock Text="Input type:" HorizontalAlignment="Center" Margin="0,10,0,0"/>
-      <DropDown Items="{Binding InputTypeList}" SelectedItem="{Binding SelectedInputType}"/>
-    </StackPanel>
-
   </Grid>
 </UserControl>