Changeset 1463


Ignore:
Timestamp:
May 22, 2010, 11:58:01 AM (12 years ago)
Author:
Sven Rech
Message:

quadratic sieve fix (is now usable again)

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/QuadraticSieve/FactorManager.cs

    r1462 r1463  
    8787        }
    8888
     89        private BigInteger DivideIntByFactors(BigInteger composite, IntPtr factorList)
     90        {
     91            throw new NotImplementedException();
     92        }
     93
    8994        /// <summary>
    9095        /// Returns a single composite factor (or 0, if no composite factors are left).
     
    107112        public BigInteger[] getPrimeFactors()
    108113        {
     114            primeFactors.Sort();
    109115            return primeFactors.ToArray();
    110116        }
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSieve.cs

    r1462 r1463  
    446446            factorManager.AddFactors(list);
    447447
    448             MethodInfo factor_mpqs = msieve.GetMethod("factor_mpqs");
     448            MethodInfo msieve_run_core = msieve.GetMethod("msieve_run_core");
    449449
    450450            //Now factorize as often as needed:
     
    455455
    456456                //now start quadratic sieve on it:               
    457                 IntPtr resultList = (IntPtr)factor_mpqs.Invoke(null, new object[2] { obj, compositeFactor.ToString() });
     457                IntPtr resultList = (IntPtr)msieve_run_core.Invoke(null, new object[2] { obj, compositeFactor.ToString() });
    458458                factorManager.ReplaceCompositeByFactors(compositeFactor, resultList);
    459459            }
  • trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/WrapperTester/Program.cs

    r1373 r1463  
    6868                    Console.Out.WriteLine((String)o);
    6969
    70                 list = Msieve.msieve.factor_mpqs(obj, (String)Msieve.msieve.getCompositeFactors(list)[0]);
     70                list = Msieve.msieve.msieve_run_core(obj, (String)Msieve.msieve.getCompositeFactors(list)[0]);
    7171                foreach (Object o in Msieve.msieve.getPrimeFactors(list))
    7272                    Console.Out.WriteLine("Prim: " + (String)o);
  • trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/msieve.dll/wrapper.cpp

    r1373 r1463  
    2323                uint32 *fb_offsets, uint32 num_factors,
    2424                uint32 poly_index, uint32 large_prime1, uint32 large_prime2);
     25//From driver.c:
     26extern "C" uint32 msieve_run_core(msieve_obj *obj, mp_t *n,
     27                                factor_list_t *factor_list);
    2528
    2629//Copy a sieve configuration that can be used in a different thread:
     
    277280                }
    278281
    279                 //get's the current factor on which we are sieving:
    280                 static String^ getCurrentFactor(IntPtr conf)
    281                 {
    282                         char buf[929];
    283                         sieve_conf_t* c = (sieve_conf_t*)conf.ToPointer();
    284                         mp_t mult;
    285                         *((uint32*)(&mult.val[0])) = c->multiplier;
    286                         mult.nwords = 4;
    287                         mp_t n;
    288                         mp_div(c->n, &mult, &n);
    289                         char* nchar = mp_sprintf(&n, 10, buf);
    290                         return gcnew String(nchar);
    291                 }
    292 
    293282                //serialize the yield, so that you can send it over the net:
    294283                static array<unsigned char>^ serializeYield(IntPtr yield)
     
    351340                }
    352341
    353                 static IntPtr factor_mpqs(IntPtr obj, String^ n)
     342                static IntPtr msieve_run_core(IntPtr obj, String^ n)
    354343                {
    355344                        mp_t N;
     345                        msieve_obj* o = (msieve_obj*)obj.ToPointer();
    356346                        evaluate_expression(stringToCharA(n), &N);
    357347                        factor_list_t* factor_list = new factor_list_t;
    358348                        factor_list_init(factor_list);
    359                         ::factor_mpqs((msieve_obj*)obj.ToPointer(), &N, factor_list);
     349                        factor_list_add(o, factor_list, &N);
     350                        ::msieve_run_core(o, &N, factor_list);
    360351                        return IntPtr(factor_list);
    361352                }
  • trunk/CrypPlugins/QuadraticSieve/msieve/common/driver.c

    r1373 r1463  
    7373
    7474/*--------------------------------------------------------------------*/
    75 static uint32 msieve_run_core(msieve_obj *obj, mp_t *n,
     75uint32 msieve_run_core(msieve_obj *obj, mp_t *n,
    7676                                factor_list_t *factor_list) {
    7777
     
    134134
    135135        /* Beyond this point we use the heavy artillery. */
    136         //return factor_mpqs(obj, n, factor_list);
    137         get_trivial_factorlist(factor_list, obj);
     136        return factor_mpqs(obj, n, factor_list);
    138137}
    139138
     
    208207        }
    209208
     209        //callback to inform Cryptool about the already found trivial factors:
     210        get_trivial_factorlist(&factor_list, obj);
     211
     212
     213        //The logic behind the following commented code will be processed by cryptool:
     214
    210215        /* while forward progress is still being made */
    211216
    212         while (1) {
    213                 uint32 num_factors = factor_list.num_factors;
    214                 status = 0;
    215 
    216                 /* process the next composite factor of n. Only
    217                    attempt one factorization at a time, since
    218                    the underlying list of factors could change */
    219 
    220                 for (i = 0; i < num_factors; i++) {
    221                         final_factor_t *f = factor_list.final_factors[i];
    222 
    223                         if (f->type == MSIEVE_COMPOSITE) {
    224                                 mp_t new_n;
    225                                 mp_copy(&f->factor, &new_n);
    226                                 status = msieve_run_core(obj, &new_n,
    227                                                         &factor_list);
    228                                 break;
    229                         }
    230                 }
    231                 if (status == 0 || (obj->flags & MSIEVE_FLAG_STOP_SIEVING))
    232                         break;
    233         }
     217        //while (1) {
     218        //      uint32 num_factors = factor_list.num_factors;
     219        //      status = 0;
     220
     221        //      /* process the next composite factor of n. Only
     222        //         attempt one factorization at a time, since
     223        //         the underlying list of factors could change */
     224
     225        //      for (i = 0; i < num_factors; i++) {
     226        //              final_factor_t *f = factor_list.final_factors[i];
     227
     228        //              if (f->type == MSIEVE_COMPOSITE) {
     229        //                      mp_t new_n;
     230        //                      mp_copy(&f->factor, &new_n);
     231        //                      status = msieve_run_core(obj, &new_n,
     232        //                                              &factor_list);
     233        //                      break;
     234        //              }
     235        //      }
     236        //      if (status == 0 || (obj->flags & MSIEVE_FLAG_STOP_SIEVING))
     237        //              break;
     238        //}
    234239
    235240clean_up:
Note: See TracChangeset for help on using the changeset viewer.