Changeset 5957


Ignore:
Timestamp:
Apr 14, 2014, 6:26:25 PM (8 years ago)
Author:
weyers
Message:

Typo corrected

Location:
trunk/CrypPluginsExperimental/SIgabaKnownPlaintext
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPluginsExperimental/SIgabaKnownPlaintext/SigabaCoreFastKnownPlaintext.cs

    r5955 r5957  
    631631                            if (letters == input2.Length - 2)
    632632                            {
    633                                 /*Console.WriteLine("we have got a winner");
    634                                 Console.WriteLine("Rotor1: " + winner.RotorType[0] + " REverse: " +
    635                                                   winner.Reverse[0] + " POsition: " + winner.Positions[0] +
    636                                                   " Rotor2: " + winner.RotorType[1] + " REverse: " +
    637                                                   winner.Reverse[1] + " POsition: " + winner.Positions[1] +
    638                                                   " Rotor3: " + winner.RotorType[2] + " REverse: " +
    639                                                   winner.Reverse[2] + " POsition: " + winner.Positions[2]);
    640                                 */
    641633                                facade.AddEntryConfirmed(winner, realWheels[rest[re]], realWheels[rest[re == 0 ? 1 : 0]]);
    642634
     
    913905                                            {
    914906                                                Console.WriteLine("we have got a winner");
    915                                                 //Console.WriteLine("Rotor 4: " + pos + testRotor.Reverse + rest[re] + wi);
    916                                                 Console.WriteLine("Rotor1: " + realWheels[winner.RotorType[0]] +
    917                                                                   " REverse: " +
    918                                                                   winner.Reverse[0] + " POsition: " +
    919                                                                   winner.Positions[0] +
    920                                                                   " Rotor2: " + realWheels[winner.RotorType[1]] +
    921                                                                   " REverse: " +
    922                                                                   winner.Reverse[1] + " POsition: " +
    923                                                                   winner.Positions[1] +
    924                                                                   " Rotor3: " + realWheels[winner.RotorType[2]] +
    925                                                                   " REverse: " +
    926                                                                   winner.Reverse[2] + " POsition: " +
    927                                                                   winner.Positions[2] +
    928                                                                   " Rotor4: " + realWheels[rest[0]] + " REverse: " +
    929                                                                   testRotor[0].Reverse + " POsition: " + pos +
    930                                                                   " Rotor5: " + realWheels[rest[1]] + " REverse: " +
    931                                                                   testRotor[1].Reverse + " POsition: " + pos2
    932                                                     );
     907                                               
    933908                                                List<int[]> indexKey = findIndexMaze(steppingmaze);
    934909                                                facade.AddEntryComplete(winner, steppingmaze, pos, pos2,
     
    12091184                                                Console.WriteLine("we have got a winner");
    12101185                                                //Console.WriteLine("Rotor 4: " + pos + testRotor.Reverse + rest[re] + wi);
    1211                                                 Console.WriteLine("Rotor1: " + realWheels[winner.RotorType[0]] +
    1212                                                                   " REverse: " +
    1213                                                                   winner.Reverse[0] + " POsition: " +
    1214                                                                   winner.Positions[0] +
    1215                                                                   " Rotor2: " + realWheels[winner.RotorType[1]] +
    1216                                                                   " REverse: " +
    1217                                                                   winner.Reverse[1] + " POsition: " +
    1218                                                                   winner.Positions[1] +
    1219                                                                   " Rotor3: " + realWheels[winner.RotorType[2]] +
    1220                                                                   " REverse: " +
    1221                                                                   winner.Reverse[2] + " POsition: " +
    1222                                                                   winner.Positions[2] +
    1223                                                                   " Rotor4: " + realWheels[rest[0]] + " REverse: " +
    1224                                                                   testRotor[0].Reverse + " POsition: " + pos +
    1225                                                                   " Rotor5: " + realWheels[rest[1]] + " REverse: " +
    1226                                                                   testRotor[1].Reverse + " POsition: " + pos2
    1227                                                     );
     1186                                               
    12281187                                                List<int[]> indexKey = findIndexMaze(steppingmaze);
    12291188                                                /*facade.AddEntryComplete(winner, steppingmaze, pos, pos2,
     
    13751334                            if (letters == input2.Length - 2)
    13761335                            {
    1377                                 /*Console.WriteLine("we have got a winner");
    1378                                 Console.WriteLine("Rotor1: " + winner.RotorType[0] + " REverse: " +
    1379                                                   winner.Reverse[0] + " POsition: " + winner.Positions[0] +
    1380                                                   " Rotor2: " + winner.RotorType[1] + " REverse: " +
    1381                                                   winner.Reverse[1] + " POsition: " + winner.Positions[1] +
    1382                                                   " Rotor3: " + winner.RotorType[2] + " REverse: " +
    1383                                                   winner.Reverse[2] + " POsition: " + winner.Positions[2]);
    1384                                 */
     1336                               
    13851337
    13861338                                for (int i = 0; i < 26; i++)
     
    16671619                                            {
    16681620                                                Console.WriteLine("we have got a winner");
    1669                                                 //Console.WriteLine("Rotor 4: " + pos + testRotor.Reverse + rest[re] + wi);
    1670                                                 Console.WriteLine("Rotor1: " + realWheels[winner.RotorType[0]] +
    1671                                                                   " REverse: " +
    1672                                                                   winner.Reverse[0] + " POsition: " +
    1673                                                                   winner.Positions[0] +
    1674                                                                   " Rotor2: " + realWheels[winner.RotorType[1]] +
    1675                                                                   " REverse: " +
    1676                                                                   winner.Reverse[1] + " POsition: " +
    1677                                                                   winner.Positions[1] +
    1678                                                                   " Rotor3: " + realWheels[winner.RotorType[2]] +
    1679                                                                   " REverse: " +
    1680                                                                   winner.Reverse[2] + " POsition: " +
    1681                                                                   winner.Positions[2] +
    1682                                                                   " Rotor5: " + realWheels[rest] + " REverse: " +
    1683                                                                   testRotor.Reverse + " POsition: " + pos
    1684                                                     );
     1621                                               
    16851622                                                returnString = new string[3];
    16861623                                                returnString[0] = "" + realWheels[rest];
     
    20662003   
    20672004
    2068 /*
    2069      public List<Candidate> stepOne(int[][] input2)
    2070         {
    2071             int[] foo = new int[26];
    2072 
    2073             List<Candidate> winnerList2 = new List<Candidate>();
    2074 
    2075             for (int i = 0; i < foo.Count(); i++)
    2076             {
    2077                 foo[i] = i;
    2078             }
    2079 
    2080             List<Candidate> winnerList = new List<Candidate>();
    2081             //List<Candidate> winnerList2 = new List<Candidate>();
    2082             //List<Candidate> winnerList3 = new List<Candidate>();
    2083 
    2084            
    2085             IEnumerable<IEnumerable<int>> combis2 = CombinationFactory.Combinations(new[] { 0, 1, 2, 3, 4 }, 3);
    2086 
    2087             RotorByte[] ControlRotors = new RotorByte[3];
    2088             int counter = 0;
    2089 
    2090             Boolean br = false;
    2091 
    2092             for (int co = 0; co < combis2.Count(); co++)
    2093             {
    2094 
    2095                 int[] arr = combis2.ElementAt(co).ToArray();
    2096 
    2097                 do
    2098                 {
    2099                     counter++;
    2100                     ControlRotors[0] = CodeWheels[arr[0]];
    2101                     ControlRotors[1] = CodeWheels[arr[1]];
    2102                     ControlRotors[2] = CodeWheels[arr[2]];
    2103                     Console.Write(arr[0]);
    2104                     Console.Write(arr[1]);
    2105                     Console.WriteLine(arr[2]);
    2106 
    2107                     Console.WriteLine("Combis.count");
    2108 
    2109                     for (int ix = 0; ix < 8; ix++)
    2110                     {
    2111                         String s = GetIntBinaryString(ix);
    2112                         if (s[0] == '1')
    2113                         {
    2114                             ControlRotors[0].Reverse = true;
    2115                         }
    2116                         else
    2117                         {
    2118                             ControlRotors[0].Reverse = false;
    2119                         }
    2120                         if (s[1] == '1')
    2121                         {
    2122                             ControlRotors[1].Reverse = true;
    2123                         }
    2124                         else
    2125                         {
    2126                             ControlRotors[1].Reverse = false;
    2127                         }
    2128                         if (s[2] == '1')
    2129                         {
    2130                             ControlRotors[2].Reverse = true;
    2131                         }
    2132                         else
    2133                         {
    2134                             ControlRotors[2].Reverse = false;
    2135                         }
    2136                         for (int co1 = 0; co1 < 26; co1++)
    2137                         {
    2138                             for (int co2 = 0; co2 < 26; co2++)
    2139                             {
    2140                                 for (int co3 = 0; co3 < 26; co3++)
    2141                                 {
    2142                                     ControlRotors[0].Position = co1;
    2143                                     ControlRotors[1].Position = co2;
    2144                                     ControlRotors[2].Position = co3;
    2145                                     int[][] pseudo = new int[26][];
    2146 
    2147                                     for (int letters = 0; letters < input2.Length; letters++)
    2148                                     {
    2149                                          int tempf = combis.ElementAt(ix).ElementAt(0);
    2150                                      int tempg = combis.ElementAt(ix).ElementAt(1);
    2151                                      int temph = combis.ElementAt(ix).ElementAt(2);
    2152                                      int tempi = combis.ElementAt(ix).ElementAt(3);
    2153                                         int tempf = 5;
    2154                                         int tempg = 6;
    2155                                         int temph = 7;
    2156                                         int tempi = 8;
    2157 
    2158 
    2159 
    2160                                         for (int i = 0; i < 3; i++)
    2161                                         {
    2162                                             //converted to:
    2163                                             if (ControlRotors[i].Reverse)
    2164                                             {
    2165                                                 tempf =
    2166                                                     ControlRotors[i].RotSubMatRevBack[ControlRotors[i].Position, tempf];
    2167                                                 tempg =
    2168                                                     ControlRotors[i].RotSubMatRevBack[ControlRotors[i].Position, tempg];
    2169                                                 temph =
    2170                                                     ControlRotors[i].RotSubMatRevBack[ControlRotors[i].Position, temph];
    2171                                                 tempi =
    2172                                                     ControlRotors[i].RotSubMatRevBack[ControlRotors[i].Position, tempi];
    2173                                             }
    2174                                             else
    2175                                             {
    2176                                                 tempf = ControlRotors[i].RotSubMatBack[ControlRotors[i].Position, tempf];
    2177                                                 tempg = ControlRotors[i].RotSubMatBack[ControlRotors[i].Position, tempg];
    2178                                                 temph = ControlRotors[i].RotSubMatBack[ControlRotors[i].Position, temph];
    2179                                                 tempi = ControlRotors[i].RotSubMatBack[ControlRotors[i].Position, tempi];
    2180                                             }
    2181 
    2182                                         }
    2183                                         /*
    2184                                     Console.Write((char)(tempf+65)+"");
    2185                                     Console.Write((char)(tempg + 65)+"");
    2186                                     Console.Write((char)(temph + 65)+"");
    2187                                     Console.Write((char)(tempi + 65)+"" + letters);
    2188                                     Console.WriteLine();
    2189                                         //Console.ReadKey();
    2190 
    2191                                         if (pseudo[tempf] == null)
    2192                                             pseudo[tempf] = input2[letters];
    2193                                         else
    2194                                         {
    2195                                             pseudo[tempf] = pseudo[tempf].Intersect(input2[letters]).ToArray();
    2196                                             if (pseudo[tempf].Count() == 0)
    2197                                             {
    2198                                                 //Console.WriteLine("bingo");
    2199                                                 break;
    2200                                             }
    2201                                         }
    2202                                         if (pseudo[tempg] == null)
    2203                                             pseudo[tempg] = input2[letters];
    2204                                         else
    2205                                         {
    2206                                             pseudo[tempg] = pseudo[tempg].Intersect(input2[letters]).ToArray();
    2207                                             if (pseudo[tempg].Count() == 0)
    2208                                             {
    2209                                                 //Console.WriteLine("bingo");
    2210                                                 break;
    2211                                             }
    2212                                         }
    2213                                         if (pseudo[temph] == null)
    2214                                             pseudo[temph] = input2[letters];
    2215                                         else
    2216                                         {
    2217                                             pseudo[temph] = pseudo[temph].Intersect(input2[letters]).ToArray();
    2218                                             if (pseudo[temph].Count() == 0)
    2219                                             {
    2220                                                 //Console.WriteLine("bingo");
    2221                                                 break;
    2222                                             }
    2223                                         }
    2224                                         if (pseudo[tempi] == null)
    2225                                             pseudo[tempi] = input2[letters];
    2226                                         else
    2227                                         {
    2228                                             pseudo[tempi] = pseudo[tempi].Intersect(input2[letters]).ToArray();
    2229                                             if (pseudo[tempi].Count() == 0)
    2230                                             {
    2231                                                 //Console.WriteLine("bingo");
    2232                                                 break;
    2233                                             }
    2234                                         }
    2235                                         if (letters == input2.Length-1)
    2236                                         {
    2237                                             /*Console.WriteLine("we have got a winner");
    2238                                             Console.WriteLine((char)(co1 + 65) + "" + (char)(co2 + 65) + "" + (char)(co3 + 65));
    2239                                             Console.WriteLine("ReverseControlRotor1:" + ControlRotors[0].Reverse + " ReverseControlRotor2:" + ControlRotors[1].Reverse + " ReverseControlRotor3:" + ControlRotors[2].Reverse);
    2240                                            
    2241                                             for (int cn = 0; cn < pseudo.Length; cn++)
    2242                                             {
    2243                                                 if (pseudo[cn] == null)
    2244                                                     pseudo[cn] = new int[] { 0, 1, 2, 3, 4 };
    2245                                             }
    2246 
    2247                                             Candidate winner = new Candidate()
    2248                                             {
    2249                                                 Positions = new int[] { co1, co2, co3 },
    2250                                                 Reverse =
    2251                                                     new bool[]
    2252                                                                                {
    2253                                                                                    ControlRotors[0].Reverse,
    2254                                                                                    ControlRotors[1].Reverse,
    2255                                                                                    ControlRotors[2].Reverse
    2256                                                                                },
    2257                                                 RotorType = new int[] { arr[0], arr[1], arr[2] },
    2258                                                 Pseudo = pseudo
    2259                                             };
    2260 
    2261                                            // Console.WriteLine("");
    2262                                             // br = true;
    2263                                             //int[][] winner = pseudo;
    2264 
    2265                                             //facade.AddPresentationEntry(winner);
    2266 
    2267                                             winnerList.Add(winner);
    2268                                             break;
    2269                                         }
    2270 
    2271 
    2272 
    2273                                         if (ControlRotors[2].Position == 14)
    2274                                         {
    2275                                             if (ControlRotors[1].Position == 14)
    2276                                             {
    2277                                                 pseudo = new int[26][];
    2278                                             }
    2279                                             ControlRotors[1].IncrementPosition();
    2280                                         }
    2281                                         ControlRotors[2].IncrementPosition();
    2282                                     }                                               //if (br) break;
    2283                                 }                                                   //if (br) break;
    2284                             }                                                       //if (br) break;
    2285                         }                                                           //if (br) break;
    2286                     }                                                               //if (br) break;
    2287                 } while (NextPermutation(arr));                                     //if (br) break;
    2288             }
    2289 
    2290             return winnerList;
    2291         }
    2292 
    2293         public List<Candidate> WinnerConfirm(int[][] input2, List<Candidate> winnerList)
    2294         {
    2295             List<Candidate> winnerList2 = new List<Candidate>();
    2296 
    2297             for (int wi = 0; wi < winnerList.Count; wi++)
    2298             {
    2299 
    2300                 Candidate winner = winnerList[wi];
    2301 
    2302                 RotorByte[] ControlRotors = new RotorByte[3];
    2303 
    2304                 ControlRotors[0] = CodeWheels[winner.RotorType[0]];
    2305                 ControlRotors[1] = CodeWheels[winner.RotorType[1]];
    2306                 ControlRotors[2] = CodeWheels[winner.RotorType[2]];
    2307 
    2308                 ControlRotors[0].Position = winner.Positions[0];
    2309 
    2310                 ControlRotors[0].Reverse = winner.Reverse[0];
    2311                 ControlRotors[1].Reverse = winner.Reverse[1];
    2312                 ControlRotors[2].Reverse = winner.Reverse[2];
    2313 
    2314 
    2315                 int[] rest = new int[2];
    2316                 bool b = true;
    2317                 for (int i = 0; i < 5; i++)
    2318                 {
    2319                     if (!winner.RotorType.Contains(i))
    2320                     {
    2321                         if (b)
    2322                         {
    2323                             rest[0] = i;
    2324                             b = false;
    2325                         }
    2326                         else
    2327                         {
    2328                             rest[1] = i;
    2329                         }
    2330 
    2331                     }
    2332                 }
    2333 
    2334                 for (int re = 0; re < 2; re++)
    2335                 {
    2336                     RotorByte testRotor = CodeWheels[rest[re]];
    2337 
    2338                     for (int rev = 0; rev < 2; rev++)
    2339                     {
    2340                         testRotor.Reverse = (rev == 1);
    2341                         for (int pos = 0; pos < 26; pos++)
    2342                         {
    2343                             ControlRotors[1].Position = winner.Positions[1];
    2344                             ControlRotors[2].Position = winner.Positions[2];
    2345                             testRotor.Position = pos;
    2346                             int[][] pseudo = new int[26][];
    2347                             if (pos == 0)
    2348                                 Console.Write("");
    2349 
    2350                             for (int letters = 0; letters < input2.Length; letters++)
    2351                             {
    2352                                 int tempf = 5;
    2353                                 int tempg = 6;
    2354                                 int temph = 7;
    2355                                 int tempi = 8;
    2356 
    2357                                 for (int i = 0; i < 3; i++)
    2358                                 {
    2359                                     //converted to:
    2360                                     if (ControlRotors[i].Reverse)
    2361                                     {
    2362                                         tempf =
    2363                                             ControlRotors[i].RotSubMatRevBack[ControlRotors[i].Position, tempf];
    2364                                         tempg =
    2365                                             ControlRotors[i].RotSubMatRevBack[ControlRotors[i].Position, tempg];
    2366                                         temph =
    2367                                             ControlRotors[i].RotSubMatRevBack[ControlRotors[i].Position, temph];
    2368                                         tempi =
    2369                                             ControlRotors[i].RotSubMatRevBack[ControlRotors[i].Position, tempi];
    2370                                     }
    2371                                     else
    2372                                     {
    2373                                         tempf = ControlRotors[i].RotSubMatBack[ControlRotors[i].Position, tempf];
    2374                                         tempg = ControlRotors[i].RotSubMatBack[ControlRotors[i].Position, tempg];
    2375                                         temph = ControlRotors[i].RotSubMatBack[ControlRotors[i].Position, temph];
    2376                                         tempi = ControlRotors[i].RotSubMatBack[ControlRotors[i].Position, tempi];
    2377                                     }
    2378 
    2379                                 }
    2380 
    2381                                 /*Console.Write((char)(tempf+65)+"");
    2382                                     Console.Write((char)(tempg + 65)+"");
    2383                                     Console.Write((char)(temph + 65)+"");
    2384                                     Console.Write((char)(tempi + 65)+"" + letters);
    2385                                     Console.WriteLine();
    2386                                     Console.ReadKey();
    2387 
    2388                                 if (testRotor.Reverse)
    2389                                 {
    2390                                     tempf =
    2391                                         testRotor.RotSubMatRevBack[testRotor.Position, tempf];
    2392                                     tempg =
    2393                                         testRotor.RotSubMatRevBack[testRotor.Position, tempg];
    2394                                     temph =
    2395                                         testRotor.RotSubMatRevBack[testRotor.Position, temph];
    2396                                     tempi =
    2397                                         testRotor.RotSubMatRevBack[testRotor.Position, tempi];
    2398                                 }
    2399                                 else
    2400                                 {
    2401                                     tempf = testRotor.RotSubMatBack[testRotor.Position, tempf];
    2402                                     tempg = testRotor.RotSubMatBack[testRotor.Position, tempg];
    2403                                     temph = testRotor.RotSubMatBack[testRotor.Position, temph];
    2404                                     tempi = testRotor.RotSubMatBack[testRotor.Position, tempi];
    2405                                 }
    2406                                 /*Console.Write((char)(tempf + 65) + "");
    2407                                 Console.Write((char)(tempg + 65) + "");
    2408                                 Console.Write((char)(temph + 65) + "");
    2409                                 Console.Write((char)(tempi + 65) + "" + letters);
    2410                                 Console.WriteLine();
    2411                                 Console.ReadKey();
    2412 
    2413                                 if (pseudo[tempf] == null)
    2414                                     pseudo[tempf] = input2[letters];
    2415                                 else
    2416                                 {
    2417                                     pseudo[tempf] = pseudo[tempf].Intersect(input2[letters]).ToArray();
    2418                                     if (pseudo[tempf].Count() == 0)
    2419                                     {
    2420                                         //Console.WriteLine("bingo");
    2421                                         break;
    2422                                     }
    2423                                 }
    2424                                 if (pseudo[tempg] == null)
    2425                                     pseudo[tempg] = input2[letters];
    2426                                 else
    2427                                 {
    2428                                     pseudo[tempg] = pseudo[tempg].Intersect(input2[letters]).ToArray();
    2429                                     if (pseudo[tempg].Count() == 0)
    2430                                     {
    2431                                         //Console.WriteLine("bingo");
    2432                                         break;
    2433                                     }
    2434                                 }
    2435                                 if (pseudo[temph] == null)
    2436                                     pseudo[temph] = input2[letters];
    2437                                 else
    2438                                 {
    2439                                     pseudo[temph] = pseudo[temph].Intersect(input2[letters]).ToArray();
    2440                                     if (pseudo[temph].Count() == 0)
    2441                                     {
    2442                                         //Console.WriteLine("bingo");
    2443                                         break;
    2444                                     }
    2445                                 }
    2446                                 if (pseudo[tempi] == null)
    2447                                     pseudo[tempi] = input2[letters];
    2448                                 else
    2449                                 {
    2450                                     pseudo[tempi] = pseudo[tempi].Intersect(input2[letters]).ToArray();
    2451                                     if (pseudo[tempi].Count() == 0)
    2452                                     {
    2453                                         //Console.WriteLine("bingo");
    2454                                         break;
    2455                                     }
    2456                                 }
    2457                                 if (letters == input2.Length-1)
    2458                                 {
    2459                                     //Console.WriteLine("we have got a winner");
    2460                                     //Console.WriteLine("Rotor 4: " + pos + testRotor.Reverse + rest[re] + wi);
    2461                                     /*Console.WriteLine("Rotor1: " + winner.RotorType[0] + " REverse: " +
    2462                                                       winner.Reverse[0] + " POsition: " + winner.Positions[0] +
    2463                                                       " Rotor2: " + winner.RotorType[1] + " REverse: " +
    2464                                                       winner.Reverse[1] + " POsition: " + winner.Positions[1] +
    2465                                                       " Rotor3: " + winner.RotorType[2] + " REverse: " +
    2466                                                       winner.Reverse[2] + " POsition: " + winner.Positions[2]);
    2467                                    
    2468                                     if(!winnerList2.Contains(winner))
    2469                                         winnerList2.Add(winner);
    2470 
    2471                                     break;
    2472                                 }
    2473 
    2474 
    2475 
    2476                                 if (ControlRotors[2].Position == 14)
    2477                                 {
    2478                                     if (ControlRotors[1].Position == 14)
    2479                                     {
    2480                                         testRotor.IncrementPosition();
    2481                                     }
    2482                                     ControlRotors[1].IncrementPosition();
    2483                                 }
    2484                                 ControlRotors[2].IncrementPosition();
    2485 
    2486                             }
    2487                         }
    2488                     }
    2489                 }
    2490             }
    2491 
    2492             return winnerList2;
    2493         }
    2494 
    2495         public List<Candidate> SteppingMazeCompletion(int[][] input2, List<Candidate> winnerList3)
    2496         {
    2497             for (int wi = 0; wi < winnerList3.Count; wi++)
    2498             {
    2499                 List<int[]> alreadyTested = new List<int[]>();
    2500                 int[] test = new int[26];
    2501                 int[][] test2 = new int[26][];
    2502                 test2 = winnerList3[wi].Pseudo;
    2503            
    2504                 for (int i0 = 0; i0 < test2[0].Length; i0++)
    2505                 for (int i1 = 0; i1 < test2[1].Length; i1++)
    2506                 for (int i2 = 0; i2 < test2[2].Length; i2++)
    2507                 for (int i3 = 0; i3 < test2[3].Length; i3++)
    2508                 for (int i4 = 0; i4 < test2[4].Length; i4++)
    2509                 for (int i5 = 0; i5 < test2[5].Length; i5++)
    2510                 for (int i6 = 0; i6 < test2[6].Length; i6++)
    2511                 for (int i7 = 0; i7 < test2[7].Length; i7++)
    2512                 for (int i8 = 0; i8 < test2[8].Length; i8++)
    2513                 for (int i9 = 0; i9 < test2[9].Length; i9++)
    2514                 for (int i10 = 0; i10 < test2[10].Length; i10++)
    2515                 for (int i11 = 0; i11 < test2[11].Length; i11++)
    2516                 for (int i12 = 0; i12 < test2[12].Length; i12++)
    2517                 for (int i13 = 0; i13 < test2[13].Length; i13++)
    2518                 for (int i14 = 0; i14 < test2[14].Length; i14++)
    2519                 for (int i15 = 0; i15 < test2[15].Length; i15++)
    2520                 for (int i16 = 0; i16 < test2[16].Length; i16++)
    2521                 for (int i17 = 0; i17 < test2[17].Length; i17++)
    2522                 for (int i18 = 0; i18 < test2[18].Length; i18++)
    2523                 for (int i19 = 0; i19 < test2[19].Length; i19++)
    2524                 for (int i20 = 0; i20 < test2[20].Length; i20++)
    2525                 for (int i21 = 0; i21 < test2[21].Length; i21++)
    2526                 for (int i22 = 0; i22 < test2[22].Length; i22++)
    2527                 for (int i23 = 0; i23 < test2[23].Length; i23++)
    2528                 for (int i24 = 0; i24 < test2[24].Length; i24++)
    2529                 for (int i25 = 0; i25 < test2[25].Length; i25++)
    2530 
    2531                 {
    2532                     Console.WriteLine(test2[0][i0] + "" + test2[1][i1] + "" + test2[2][i2] + "" + test2[3][i3] + "" +
    2533                                       test2[4][i4] + "" + test2[5][i5] + "" + test2[6][i6] + "" + test2[7][i7] + "" +
    2534                                       test2[8][i8] + "" + test2[9][i9] + "" + test2[10][i10] + "" + test2[11][i11] + "" +
    2535                                       test2[12][i12] + "" + test2[13][i13] + "" + test2[14][i14] + "" + test2[15][i15] +
    2536                                       "" + test2[16][i16] + "" + test2[17][i17] + "" + test2[18][i18] + "" +
    2537                                       test2[19][i19] + "" + test2[20][i20] + "" + test2[21][i21] + "" + test2[22][i22] +
    2538                                       "" + test2[23][i23] + "" + test2[24][i24] + "" + test2[25][i25] + "");
    2539 
    2540                     test[0] = test2[0][i0];
    2541                     test[1] = test2[1][i1];
    2542                     test[2] = test2[2][i2];
    2543                     test[3] = test2[3][i3];
    2544                     test[4] = test2[4][i4];
    2545                     test[5] = test2[5][i5];
    2546                     test[6] = test2[6][i6];
    2547                     test[7] = test2[7][i7];
    2548                     test[8] = test2[8][i8];
    2549                     test[9] = test2[9][i9];
    2550                     test[10] = test2[10][i10];
    2551                     test[11] = test2[11][i11];
    2552                     test[12] = test2[12][i12];
    2553                     test[13] = test2[13][i13];
    2554                     test[14] = test2[14][i14];
    2555                     test[15] = test2[15][i15];
    2556                     test[16] = test2[16][i16];
    2557                     test[17] = test2[17][i17];
    2558                     test[18] = test2[18][i18];
    2559                     test[19] = test2[19][i19];
    2560                     test[20] = test2[20][i20];
    2561                     test[21] = test2[21][i21];
    2562                     test[22] = test2[22][i22];
    2563                     test[23] = test2[23][i23];
    2564                     test[24] = test2[24][i24];
    2565                     test[25] = test2[25][i25];
    2566 
    2567                     int counter1 = 0;
    2568                     int counter2 = 0;
    2569                     int counter3 = 0;
    2570                     int counter4 = 0;
    2571                     int counter5 = 0;
    2572 
    2573 
    2574 
    2575                     foreach (int ix1 in test)
    2576                     {
    2577                         if (ix1 == 0)
    2578                             counter1++;
    2579                         if (ix1 == 1)
    2580                             counter2++;
    2581                         if (ix1 == 2)
    2582                             counter3++;
    2583                         if (ix1 == 3)
    2584                             counter4++;
    2585                         if (ix1 == 4)
    2586                             counter5++;
    2587                     }
    2588 
    2589                     Console.WriteLine("0: " + counter1);
    2590                     Console.WriteLine("1: " + counter2);
    2591                     Console.WriteLine("2: " + counter3);
    2592                     Console.WriteLine("3: " + counter4);
    2593                     Console.WriteLine("4: " + counter5);
    2594 
    2595                     int[] countarr = { counter1, counter2, counter3, counter4, counter5 };
    2596                     Array.Sort(countarr);
    2597 
    2598 
    2599                     Boolean brB = false;
    2600                     for (int cm = 0; cm < alreadyTested.Count; cm++)
    2601                     {
    2602                         Boolean bev = false;
    2603                         for (int cn = 0; cn < alreadyTested[cm].Length; cn++)
    2604                         {
    2605                             if (alreadyTested[cm][cn] != countarr[cn])
    2606                             {
    2607                                 bev = true;
    2608                             }
    2609                         }
    2610                         if (!bev)
    2611                         {
    2612                             brB = true;
    2613                             break;
    2614                         }
    2615                     }
    2616                     if (brB)
    2617                     { break; }
    2618                     alreadyTested.Add(countarr);
    2619 
    2620                     if (counter1 + counter2 + counter3 + counter4 + counter5 != 26)
    2621                     {
    2622                         break;
    2623                     }
    2624 
    2625                     List<int[][]> l3 = IndexPermutations(new[] { counter1, counter2, counter3, counter4, counter5 });
    2626 
    2627                     Candidate winner = winnerList3[wi];
    2628 
    2629                     RotorByte[] ControlRotors = new RotorByte[3];
    2630 
    2631                     ControlRotors[0] = CodeWheels[winner.RotorType[0]];
    2632                     ControlRotors[1] = CodeWheels[winner.RotorType[1]];
    2633                     ControlRotors[2] = CodeWheels[winner.RotorType[2]];
    2634 
    2635                     ControlRotors[0].Position = winner.Positions[0];
    2636 
    2637                     ControlRotors[0].Reverse = winner.Reverse[0];
    2638                     ControlRotors[1].Reverse = winner.Reverse[1];
    2639                     ControlRotors[2].Reverse = winner.Reverse[2];
    2640 
    2641 
    2642 
    2643                     int[] rest = new int[2];
    2644 
    2645                     bool b = true;
    2646                     for (int i = 0; i < 5; i++)
    2647                     {
    2648                         if (!winner.RotorType.Contains(i))
    2649                         {
    2650                             if (b)
    2651                             {
    2652                                 rest[0] = i;
    2653                                 b = false;
    2654                             }
    2655                             else
    2656                             {
    2657                                 rest[1] = i;
    2658                             }
    2659 
    2660                         }
    2661                     }
    2662 
    2663                     for (int re = 0; re < 2; re++)
    2664                     {
    2665                         RotorByte[] testRotor = new RotorByte[2];
    2666                         testRotor[0] = CodeWheels[rest[re]];
    2667                         Console.WriteLine("");
    2668                         if (re == 1)
    2669                         {
    2670                             testRotor[1] = CodeWheels[rest[0]];
    2671                             Console.Write(rest[0]);
    2672                             Console.Write(rest[1]);
    2673                         }
    2674                         else
    2675                         {
    2676                             testRotor[1] = CodeWheels[rest[1]];
    2677                             Console.Write(rest[1]);
    2678                             Console.Write(rest[0]);
    2679                         }
    2680 
    2681                         Console.WriteLine("Combis.count");
    2682 
    2683                         for (int rev = 0; rev < 2; rev++)
    2684                         {
    2685                             testRotor[0].Reverse = (rev == 1);
    2686                             for (int rev1 = 0; rev1 < 2; rev1++)
    2687                             {
    2688                                 testRotor[1].Reverse = (rev1 == 1);
    2689                                 for (int pos = 0; pos < 26; pos++)
    2690                                 {
    2691                                     for (int pos2 = 0; pos2 < 26; pos2++)
    2692                                     {
    2693                                         for (int indpo = 0; indpo < l3.Count; indpo++)
    2694                                         {
    2695                                             ControlRotors[1].Position = winner.Positions[1];
    2696                                             ControlRotors[2].Position = winner.Positions[2];
    2697                                             testRotor[0].Position = pos;
    2698                                             testRotor[1].Position = pos2;
    2699 
    2700                                             int[][] pseudo = new int[26][];
    2701                                             if (pos == 0)
    2702                                                 Console.Write("");
    2703 
    2704                                             for (int letters = 0; letters < input2.Length; letters++)
    2705                                             {
    2706                                                 int tempf = 5;
    2707                                                 int tempg = 6;
    2708                                                 int temph = 7;
    2709                                                 int tempi = 8;
    2710 
    2711                                                 for (int i = 0; i < 3; i++)
    2712                                                 {
    2713                                                     //converted to:
    2714                                                     if (ControlRotors[i].Reverse)
    2715                                                     {
    2716                                                         tempf =
    2717                                                             ControlRotors[i].RotSubMatRevBack[
    2718                                                                 ControlRotors[i].Position, tempf];
    2719                                                         tempg =
    2720                                                             ControlRotors[i].RotSubMatRevBack[
    2721                                                                 ControlRotors[i].Position, tempg];
    2722                                                         temph =
    2723                                                             ControlRotors[i].RotSubMatRevBack[
    2724                                                                 ControlRotors[i].Position, temph];
    2725                                                         tempi =
    2726                                                             ControlRotors[i].RotSubMatRevBack[
    2727                                                                 ControlRotors[i].Position, tempi];
    2728                                                     }
    2729                                                     else
    2730                                                     {
    2731                                                         tempf =
    2732                                                             ControlRotors[i].RotSubMatBack[
    2733                                                                 ControlRotors[i].Position, tempf];
    2734                                                         tempg =
    2735                                                             ControlRotors[i].RotSubMatBack[
    2736                                                                 ControlRotors[i].Position, tempg];
    2737                                                         temph =
    2738                                                             ControlRotors[i].RotSubMatBack[
    2739                                                                 ControlRotors[i].Position, temph];
    2740                                                         tempi =
    2741                                                             ControlRotors[i].RotSubMatBack[
    2742                                                                 ControlRotors[i].Position, tempi];
    2743                                                     }
    2744 
    2745                                                 }
    2746 
    2747                                                 /*Console.Write((char)(tempf+65)+"");
    2748                                           Console.Write((char)(tempg + 65)+"");
    2749                                           Console.Write((char)(temph + 65)+"");
    2750                                           Console.Write((char)(tempi + 65)+"" + letters);
    2751                                           Console.WriteLine();
    2752                                           Console.ReadKey();
    2753                                                 for (int i = 0; i < 2; i++)
    2754                                                 {
    2755                                                     if (testRotor[i].Reverse)
    2756                                                     {
    2757                                                         tempf =
    2758                                                             testRotor[i].RotSubMatRevBack[
    2759                                                                 testRotor[i].Position, tempf];
    2760                                                         tempg =
    2761                                                             testRotor[i].RotSubMatRevBack[
    2762                                                                 testRotor[i].Position, tempg];
    2763                                                         temph =
    2764                                                             testRotor[i].RotSubMatRevBack[
    2765                                                                 testRotor[i].Position, temph];
    2766                                                         tempi =
    2767                                                             testRotor[i].RotSubMatRevBack[
    2768                                                                 testRotor[i].Position, tempi];
    2769                                                     }
    2770                                                     else
    2771                                                     {
    2772                                                         tempf =
    2773                                                             testRotor[i].RotSubMatBack[testRotor[i].Position, tempf];
    2774                                                         tempg =
    2775                                                             testRotor[i].RotSubMatBack[testRotor[i].Position, tempg];
    2776                                                         temph =
    2777                                                             testRotor[i].RotSubMatBack[testRotor[i].Position, temph];
    2778                                                         tempi =
    2779                                                             testRotor[i].RotSubMatBack[testRotor[i].Position, tempi];
    2780                                                     }
    2781                                                 }
    2782                                                 /*Console.Write((char)(tempf + 65) + "");
    2783                                         Console.Write((char)(tempg + 65) + "");
    2784                                         Console.Write((char)(temph + 65) + "");
    2785                                         Console.Write((char)(tempi + 65) + "" + letters);
    2786                                         Console.WriteLine();
    2787                                         Console.ReadKey();
    2788                                                 int[] steppingmaze = new int[10];
    2789                                                 for (int i = 0; i < 10; i++)
    2790                                                 {
    2791                                                     for (int ix = 0; ix < 5; ix++)
    2792                                                     {
    2793                                                         if (l3[indpo][ix].Contains(i))
    2794                                                         {
    2795                                                             steppingmaze[i] = ix;
    2796                                                         }
    2797                                                     }
    2798 
    2799                                                 }
    2800 
    2801                                                 tempf = ConstantsByte.Transform[0][tempf];
    2802                                                 tempg = ConstantsByte.Transform[0][tempg];
    2803                                                 temph = ConstantsByte.Transform[0][temph];
    2804                                                 tempi = ConstantsByte.Transform[0][tempi];
    2805 
    2806                                                 tempf = steppingmaze[tempf];
    2807                                                 tempg = steppingmaze[tempg];
    2808                                                 temph = steppingmaze[temph];
    2809                                                 tempi = steppingmaze[tempi];
    2810 
    2811                                                 if (!input2[letters].Contains(tempf) ||
    2812                                                     !input2[letters].Contains(tempg) ||
    2813                                                     !input2[letters].Contains(temph) ||
    2814                                                     !input2[letters].Contains(tempi))
    2815                                                     break;
    2816 
    2817 
    2818                                                 if (letters == input2.Length-1)
    2819                                                 {
    2820                                                     Console.WriteLine("we have got a winner");
    2821                                                     //Console.WriteLine("Rotor 4: " + pos + testRotor.Reverse + rest[re] + wi);
    2822                                                     Console.WriteLine("Rotor1: " + winner.RotorType[0] +
    2823                                                                       " REverse: " +
    2824                                                                       winner.Reverse[0] + " POsition: " +
    2825                                                                       winner.Positions[0] +
    2826                                                                       " Rotor2: " + winner.RotorType[1] +
    2827                                                                       " REverse: " +
    2828                                                                       winner.Reverse[1] + " POsition: " +
    2829                                                                       winner.Positions[1] +
    2830                                                                       " Rotor3: " + winner.RotorType[2] +
    2831                                                                       " REverse: " +
    2832                                                                       winner.Reverse[2] + " POsition: " +
    2833                                                                       winner.Positions[2] +
    2834                                                                       " Rotor4: " + rest[0] + " REverse: " +
    2835                                                                       testRotor[0].Reverse + " POsition: " + pos +
    2836                                                                       " Rotor5: " + rest[1] + " REverse: " +
    2837                                                                       testRotor[1].Reverse + " POsition: " + pos2
    2838                                                         );
    2839                                                     break;
    2840                                                 }
    2841 
    2842 
    2843 
    2844                                                 if (ControlRotors[2].Position == 14)
    2845                                                 {
    2846                                                     if (ControlRotors[1].Position == 14)
    2847                                                     {
    2848                                                         testRotor[0].IncrementPosition();
    2849                                                     }
    2850                                                     ControlRotors[1].IncrementPosition();
    2851                                                 }
    2852                                                 ControlRotors[2].IncrementPosition();
    2853                                             }
    2854                                         }
    2855                                     }
    2856                                 }
    2857                             }
    2858                         }
    2859                     }
    2860                 }}
    2861             return winnerList3;
    2862         }
    2863 
    2864      */
    2865 
    2866 
     2005
     2006
     2007
  • trunk/CrypPluginsExperimental/SIgabaKnownPlaintext/SigabaKnownPlaintext.cs

    r5955 r5957  
    10761076            var lvi = sender as ListViewItem;
    10771077            var rse = lvi.Content as ResultEntry;
    1078             Console.WriteLine(Int32.Parse(rse.Ranking) - 1 +"TEst");
     1078           
    10791079            if (!list1.ElementAt( Int32.Parse(rse.Ranking)-1).tested)
    10801080            if (rse != null)
    10811081            {
     1082                Console.WriteLine(Int32.Parse(rse.Ranking) - 1 + "TEst");
    10821083                int[] rotorTypReal = new int[]
    10831084                                         {
     
    10861087                                         };
    10871088
    1088                 /*foreach (ValueKey valueKey in bestlist)
    1089                 {
    1090                     int[] test2 = new int[]
    1091                                       {4, 4, 3, 3, 2, 4, 4, 2, 3, 4, 3, 1, 4, 4, 4, 3, 1, 4, 4, 4, 4, 2, 4, 3, 3, 3};
    1092 
    1093                     Boolean blup = true;
    1094                     if (valueKey.pseudo != null)
    1095                     {
    1096                         for (int i = 0; i < test2.Length; i++)
    1097                         {
    1098                             if (valueKey.pseudo[i] != test2[i])
    1099                                 blup = false;
    1100                         }
    1101 
    1102                         if (blup)
    1103                             Console.WriteLine("Something went wrong");
    1104                     }
    1105                 }*/
     1089               
    11061090                int[] tmp = (int[]) rotorTypReal.Clone();
    11071091                    Array.Sort(tmp);
     
    11101094                        rotorTyp[i] = Array.IndexOf(tmp, rotorTypReal[i]);
    11111095               
    1112 /*                int[] test2 = new int[] { 4, 4, 3, 3, 2, 4, 4, 2, 3, 4, 3, 1, 4, 4, 4, 3, 1, 4, 4, 4, 4, 2, 4, 3, 3, 3 };
    1113 
    1114                 Boolean blup = true;
    1115                 for (int i = 0; i < test2.Length; i++)
    1116                 {
    1117                     if (bestlist[rse.Ranking[0] - 49].pseudo[i] != test2[i])
    1118                         blup = false;
    1119                 }
    1120 
    1121                 if (blup)
    1122                     Console.WriteLine("Hello");
    1123                     */
     1096
    11241097
    11251098                Candidate c = new Candidate()
Note: See TracChangeset for help on using the changeset viewer.