Changeset 1448


Ignore:
Timestamp:
May 20, 2010, 12:35:16 PM (12 years ago)
Author:
Sven Rech
Message:

replaced all BigInteger stuff with the new BigInteger class from .net 4.0

But there are still problems with some plugins (Keysearcher, BigInteger Operations...)

Location:
trunk
Files:
1 added
1 deleted
35 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPluginBase/CrypPluginBase.csproj

    r1408 r1448  
    112112    </Reference>
    113113    <Reference Include="System.Drawing" />
     114    <Reference Include="System.Numerics" />
    114115    <Reference Include="System.Xaml" />
    115116    <Reference Include="System.Xml.Linq">
     
    138139    <Compile Include="IO\CStreamWriter.cs" />
    139140    <Compile Include="IO\DirectoryHelper.cs" />
     141    <Compile Include="Miscellaneous\BigIntegerHelper.cs" />
    140142    <Compile Include="Miscellaneous\DataManager.cs" />
    141143    <Compile Include="IApplication.cs" />
     
    145147    <Compile Include="Generator\IGenerator.cs" />
    146148    <Compile Include="Control\IControl.cs" />
    147     <Compile Include="Miscellaneous\BigInteger.cs" />
    148149    <Compile Include="Miscellaneous\DescriptionHyperlink.cs" />
    149150    <Compile Include="Miscellaneous\EventsHelper.cs" />
  • trunk/CrypPluginBase/Delegates.cs

    r1137 r1448  
    1919using Cryptool.PluginBase.Control;
    2020using Cryptool.PluginBase.Miscellaneous;
     21using System.Numerics;
    2122
    2223namespace Cryptool.PluginBase
  • trunk/CrypPlugins/BigNumber/BigNumber.csproj

    r1416 r1448  
    108108      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    109109    </Reference>
     110    <Reference Include="System.Numerics" />
    110111    <Reference Include="System.Xaml" />
    111112    <Reference Include="System.Xml.Linq">
  • trunk/CrypPlugins/BigNumber/BigNumberInput.cs

    r807 r1448  
    2424using Cryptool.PluginBase;
    2525using System.ComponentModel;
     26using System.Numerics;
    2627
    2728namespace Cryptool.Plugins.BigNumber
     
    3940        #region Properties
    4041
    41         private BigInteger numberOutput = null;
     42        private BigInteger numberOutput = 0;
    4243        /// <summary>
    4344        /// The output is defined
     
    105106            try
    106107            {
    107                 bi = BigInteger.parseExpression(settings.Number);               
     108                bi = BigIntegerHelper.parseExpression(settings.Number);               
    108109            }
    109110            catch (Exception ex)
  • trunk/CrypPlugins/BigNumber/BigNumberOperation.cs

    r973 r1448  
    2020using Cryptool.PluginBase.Miscellaneous;
    2121using System.ComponentModel;
     22using System.Numerics;
    2223
    2324namespace Cryptool.Plugins.BigNumber
     
    3031        #region private variable
    3132        //The variables are defined
    32         private BigInteger input1 = null;
    33         private BigInteger input2 = null;
    34         private BigInteger mod = null;
    35         private BigInteger output = null;
     33        private BigInteger input1 = 0;
     34        private BigInteger input2 = 0;
     35        private BigInteger mod = 0;
     36        private BigInteger output = 0;
    3637        private BigNumberOperationSettings settings = new BigNumberOperationSettings();
    3738
     
    153154        public void PreExecution()
    154155        {
    155             input1 = null;
    156             input2 = null;
    157             mod = null;
     156            input1 = 0;
     157            input2 = 0;
     158            mod = 0;
    158159        }
    159160
     
    174175                        // x + y
    175176                        case 0:
    176                             if (Mod is object)
     177                            if (Mod != 0)
    177178                                Output = (Input1 + Input2) % Mod;
    178179                            else
     
    181182                        // x - y
    182183                        case 1:
    183                             if (Mod is object)
     184                            if (Mod != 0)
    184185                                Output = (Input1 - Input2) % Mod;
    185186                            else
     
    188189                        //x * y
    189190                        case 2:
    190                             if (Mod is object)
     191                            if (Mod != 0)
    191192                                Output = (Input1 * Input2) % Mod;
    192193                            else
     
    195196                        // x / y
    196197                        case 3:
    197                             if (Mod is object)
     198                            if (Mod != 0)
    198199                                Output = (Input1 / Input2) % Mod;
    199200                            else
     
    202203                        // x ^ y
    203204                        case 4:
    204                             if (Mod is object)
     205                            if (Mod != 0)
    205206                            {
    206207                                if (Input2 >= 0)
    207                                     Output = Input1.modPow(Input2, Mod);
     208                                    Output = BigInteger.ModPow(Input1, Input2, Mod);
    208209                                else
    209210                                {
    210                                     Output = Input1.modInverse(Mod).modPow(-Input2, Mod);
     211                                    Output = BigInteger.ModPow(BigIntegerHelper.ModInverse(Input1, Mod), -Input2, Mod);
    211212                                }
    212213                            }
    213214                            else
    214215                            {
    215                                 Output = Input1.pow(Input2);
     216                                Output = BigInteger.Pow(Input1, (int)Input2);
    216217                            }
    217218                            break;
    218219                        // gcd(x,y)
    219220                        case 5:
    220                                 Output = Input1.gcd(Input2);
     221                            Output = BigInteger.GreatestCommonDivisor(Input1, Input2);
    221222                            break;
    222223                    }
  • trunk/CrypPlugins/Converter/Converter.cs

    r1237 r1448  
    2525using System.Runtime.CompilerServices;
    2626using Cryptool.Plugins.Converter;
     27using System.Numerics;
    2728
    2829namespace Cryptool.Plugins.Converter
     
    270271                            {
    271272
    272                                 BigInteger temp = BigInteger.parseExpression(inpString);
     273                                BigInteger temp = BigIntegerHelper.parseExpression(inpString);
    273274
    274275                                Output = temp;
     
    312313                                try // can be read as biginteger?
    313314                                {
    314                                     BigInteger tempbigint = new BigInteger(inpString, 10);
    315 
    316                                     int numBits = tempbigint.bitCount();
    317 
    318                                     int numBytes = numBits >> 3;
    319                                     if ((numBits & 0x7) != 0)
    320                                         numBytes++;
    321                                     byte[] temp = new byte[numBytes];
    322                                     temp = tempbigint.getBytes();
    323 
    324                                     BigInteger test = new BigInteger(temp);
    325 
    326                                     Output = temp;
     315                                    BigInteger tempbigint = BigInteger.Parse(inpString);
     316                                    Output = tempbigint;
    327317
    328318                                    ProgressChanged(100, 100);
  • trunk/CrypPlugins/Converter/Converter.csproj

    r1416 r1448  
    108108      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    109109    </Reference>
     110    <Reference Include="System.Numerics" />
    110111    <Reference Include="System.Xaml" />
    111112    <Reference Include="System.Xml.Linq">
  • trunk/CrypPlugins/KeyPatternJob/DistributableKeyPatternJob.cs

    r1223 r1448  
    2020using KeySearcher;
    2121using Cryptool.PluginBase.Miscellaneous;
     22using System.Numerics;
    2223
    2324namespace Cryptool.Plugins.PeerToPeer.Jobs
     
    120121        {
    121122            byte[] serializedJob = null;
    122             jobId = null;
     123            jobId = -1;
    123124
    124125            if (this.patternBuffer.Count > 0)
  • trunk/CrypPlugins/KeyPatternJob/KeyPatternJob.csproj

    r1416 r1448  
    103103      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    104104    </Reference>
     105    <Reference Include="System.Numerics" />
    105106    <Reference Include="System.Xml.Linq">
    106107      <RequiredTargetFramework>3.5</RequiredTargetFramework>
  • trunk/CrypPlugins/KeyPatternJob/KeyPatternJobPart.cs

    r1137 r1448  
    2222using System.IO;
    2323using Cryptool.PluginBase.Miscellaneous;
     24using System.Numerics;
    2425
    2526/*
     
    9798                byte[] jobIdByte = new byte[BitConverter.ToInt32(intBuffer, 0)];
    9899                memStream.Read(jobIdByte, 0, jobIdByte.Length);
    99                 BigInteger temp_jobId = new BigInteger(jobIdByte, jobIdByte.Length);
     100                BigInteger temp_jobId = new BigInteger(jobIdByte);
    100101               
    101102                // deserialize KeyPattern
     
    160161            {
    161162                // serialize JobId
    162                 byte[] byteJobId = this.JobId.getBytes();
     163                byte[] byteJobId = this.JobId.ToByteArray();
    163164                byte[] jobIdLen = BitConverter.GetBytes(byteJobId.Length);
    164165                memStream.Write(jobIdLen, 0, jobIdLen.Length);
  • trunk/CrypPlugins/KeyPatternJob/KeyPatternJobResult.cs

    r1137 r1448  
    2020using Cryptool.PluginBase.Miscellaneous;
    2121using System.IO;
     22using System.Numerics;
    2223
    2324namespace Cryptool.Plugins.PeerToPeer.Jobs
  • trunk/CrypPlugins/KeySearcher/KeyPattern.cs

    r1182 r1448  
    2323using Cryptool.Plugins.PeerToPeer.Jobs;
    2424using System.IO;
     25using System.Numerics;
    2526
    2627namespace KeySearcher
  • trunk/CrypPlugins/KeySearcher/KeyPatternPool.cs

    r1169 r1448  
    66using System.Collections;
    77using Cryptool.Plugins.PeerToPeer.Jobs;
     8using System.Numerics;
    89
    910namespace KeySearcher
     
    4041                        splittingQuotient[c] = k;
    4142                        BigInteger size = GetPartSize();
    42                         if ((size - partsize).abs() < (bestSize - partsize).abs())                       
     43                        if (BigInteger.Abs((size - partsize)) < BigInteger.Abs(bestSize - partsize))
    4344                            bestSize = size;                       
    4445                        else
     
    165166        public long Count()
    166167        {
    167             return (TotalAmount() + stack.Count - counter).LongValue();
     168            return (long)(TotalAmount() + stack.Count - counter);
    168169        }
    169170
  • trunk/CrypPlugins/KeySearcher/KeySearcher.cs

    r1244 r1448  
    1414using System.IO;
    1515using Cryptool.PluginBase.IO;
     16using System.Numerics;
    1617
    1718namespace KeySearcher
     
    674675
    675676            LinkedListNode<ValueKey> linkedListNode;
    676             ProgressChanged(Math.Pow(10, keycounter.log(10) - size.log(10)), 1.0);
     677            ProgressChanged(Math.Pow(10, BigInteger.Log(keycounter, 10) - BigInteger.Log(size, 10)), 1.0);
    677678
    678679            if (QuickWatchPresentation.IsVisible && doneKeys != 0 && !stop)
    679680            {
    680                 double time = (Math.Pow(10, (size - keycounter).log(10) - doneKeys.log(10)));
     681                double time = (Math.Pow(10, BigInteger.Log((size - keycounter), 10) - BigInteger.Log(doneKeys, 10)));
    681682                TimeSpan timeleft = new TimeSpan(-1);
    682683
  • trunk/CrypPlugins/KeySearcher/KeySearcher.csproj

    r1417 r1448  
    108108      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    109109    </Reference>
     110    <Reference Include="System.Numerics" />
    110111    <Reference Include="System.Xaml" />
    111112    <Reference Include="System.Xml.Linq">
  • trunk/CrypPlugins/KeySearcher_IControl/KeySearcher_IControl.cs

    r1154 r1448  
    3131using Cryptool.Plugins.PeerToPeer.Jobs;
    3232using System.Threading;
     33using System.Numerics;
    3334
    3435namespace Cryptool.Plugins.KeySearcher_IControl
     
    163164        public bool StartProcessing(byte[] job, out BigInteger jobId)
    164165        {
    165             jobId = null; //out parameter
     166            jobId = -1; //out parameter
    166167            if (job != null)
    167168            {
  • trunk/CrypPlugins/KeySearcher_IControl/KeySearcher_IControl.csproj

    r1416 r1448  
    108108      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    109109    </Reference>
     110    <Reference Include="System.Numerics" />
    110111    <Reference Include="System.Xaml" />
    111112    <Reference Include="System.Xml.Linq">
  • trunk/CrypPlugins/PeerToPeerJobs/IDistributableJob.cs

    r1244 r1448  
    1818using System.Linq;
    1919using System.Text;
    20 using Cryptool.PluginBase.Miscellaneous;
     20using System.Numerics;
    2121
    2222namespace Cryptool.Plugins.PeerToPeer.Jobs
  • trunk/CrypPlugins/PeerToPeerJobs/IJobPart.cs

    r1137 r1448  
    1919using System.Text;
    2020using Cryptool.PluginBase.Miscellaneous;
     21using System.Numerics;
    2122
    2223namespace Cryptool.Plugins.PeerToPeer.Jobs
  • trunk/CrypPlugins/PeerToPeerJobs/IJobResult.cs

    r1137 r1448  
    1919using System.Text;
    2020using Cryptool.PluginBase.Miscellaneous;
     21using System.Numerics;
    2122
    2223namespace Cryptool.Plugins.PeerToPeer.Jobs
  • trunk/CrypPlugins/PeerToPeerJobs/JobMessages.cs

    r1348 r1448  
    1919using System.Text;
    2020using Cryptool.PluginBase.Miscellaneous;
     21using System.Numerics;
    2122
    2223namespace Cryptool.Plugins.PeerToPeer.Jobs
     
    122123        {
    123124            byte[] serializedJobPart = null;
    124             jobId = null;
     125            jobId = -1;
    125126            if ((MessageJobType)data[0] == MessageJobType.JobPart)
    126127            {
     
    173174        {
    174175            byte[] serializedJobResult = null;
    175             jobId = null;
     176            jobId = -1;
    176177            if ((MessageJobType)data[0] == MessageJobType.JobResult)
    177178            {
     
    318319                // Note, there is a Bug in BigInt: BigInt b = 256; => b.dataLength = 1 -- it should be 2!
    319320                // As a workarround rely on getBytes().Length (the null bytes for the BigInt 0 should be fixed now)
    320                 byte[] jobIdBytes = jobId.getBytes();
     321                byte[] jobIdBytes = jobId.ToByteArray();
    321322                byte[] jobIdBytesLen = BitConverter.GetBytes(jobIdBytes.Length);
    322323             
     
    346347            int iInt32 = 4;
    347348
    348             BigInteger result = null;
     349            BigInteger result = -1;
    349350            bytesLeft = serializedJobId.Length;
    350351            if (serializedJobId != null && serializedJobId.Length > iInt32)
     
    355356                byte[] bigIntByte = new byte[bigIntLen];
    356357                Buffer.BlockCopy(serializedJobId, bigIntByteLen.Length, bigIntByte, 0, bigIntByte.Length);
    357                 result = new BigInteger(bigIntByte, bigIntByte.Length);
     358                result = new BigInteger(bigIntByte);
    358359                bytesLeft = serializedJobId.Length - iInt32 - bigIntByte.Length;
    359360            }
  • trunk/CrypPlugins/PeerToPeerJobs/JobPart.cs

    r1137 r1448  
    1919using System.Text;
    2020using Cryptool.PluginBase.Miscellaneous;
     21using System.Numerics;
    2122
    2223namespace Cryptool.Plugins.PeerToPeer.Jobs
  • trunk/CrypPlugins/PeerToPeerJobs/JobResult.cs

    r1137 r1448  
    2121using System.Reflection;
    2222using Cryptool.PluginBase.Miscellaneous;
     23using System.Numerics;
    2324
    2425namespace Cryptool.Plugins.PeerToPeer.Jobs
     
    103104                byte[] jobIdByte = new byte[jobIdLen];
    104105                memStream.Read(jobIdByte, 0, jobIdByte.Length);
    105                 temp_jobId = new BigInteger(jobIdByte, jobIdByte.Length);
     106                temp_jobId = new BigInteger(jobIdByte);
    106107
    107108                /* Deserialize Job result data */
     
    219220            {
    220221                /* Serialize jobId */
    221                 byte[] jobIdByte = this.JobId.getBytes();
     222                byte[] jobIdByte = this.JobId.ToByteArray();
    222223                byte[] jobIdLen = BitConverter.GetBytes(jobIdByte.Length);
    223224                memStream.Write(jobIdLen, 0, jobIdLen.Length);
  • trunk/CrypPlugins/PeerToPeerJobs/PeerToPeerJobs.csproj

    r1416 r1448  
    104104    </Reference>
    105105    <Reference Include="System.Drawing" />
     106    <Reference Include="System.Numerics" />
    106107    <Reference Include="System.Windows.Forms" />
    107108    <Reference Include="System.Xml.Linq">
  • trunk/CrypPlugins/PeerToPeerManager_NEW/P2PManagerBase_NEW.cs

    r1433 r1448  
    2323using Cryptool.PluginBase.Miscellaneous;
    2424using Cryptool.Plugins.PeerToPeer.Internal;
     25using System.Numerics;
    2526
    2627/* TODO:
     
    282283        private void HandleJobAcceptanceMessage(PeerId sender, byte[] data)
    283284        {
    284             BigInteger jobId = null;
     285            BigInteger jobId = 0;
    285286            if (JobMessages.GetJobAcceptanceMessage(data, out jobId))
    286287            {
     
    455456        {
    456457            int i = 0;
    457             BigInteger temp_jobId = null;
     458            BigInteger temp_jobId = 0;
    458459            List<PeerId> freePeers = ((WorkersManagement)this.peerManagement).GetFreeWorkers();
    459460
     
    506507        {
    507508            double jobProgressInPercent;
    508             double lFinishedAmount = (double)this.distributableJobControl.FinishedAmount.LongValue();
    509             double lAllocatedAmount = (double)this.distributableJobControl.AllocatedAmount.LongValue();
    510             double lTotalAmount = (double)this.distributableJobControl.TotalAmount.LongValue();
     509            double lFinishedAmount = (double)(long)this.distributableJobControl.FinishedAmount;
     510            double lAllocatedAmount = (double)(long)this.distributableJobControl.AllocatedAmount;
     511            double lTotalAmount = (double)(long)this.distributableJobControl.TotalAmount;
    511512
    512513            if (lFinishedAmount > 0 && lAllocatedAmount > 0)
     
    541542        {
    542543            DateTime retTime = DateTime.MaxValue;
    543             if (this.distributableJobControl.FinishedAmount.LongValue() > 0)
     544            if ((long)this.distributableJobControl.FinishedAmount > 0)
    544545            {
    545546                TimeSpan bruteforcingTime = DateTime.Now.Subtract(this.StartWorkingTime);
    546                 double jobsPerSecond = bruteforcingTime.TotalSeconds / this.distributableJobControl.FinishedAmount.LongValue();
     547                double jobsPerSecond = bruteforcingTime.TotalSeconds / (long)this.distributableJobControl.FinishedAmount;
    547548                double restSeconds = jobsPerSecond *
    548                     (this.distributableJobControl.TotalAmount - this.distributableJobControl.FinishedAmount).LongValue();
     549                    (long)(this.distributableJobControl.TotalAmount - this.distributableJobControl.FinishedAmount);
    549550                //retTime.TotalSeconds = jobsPerSecond * (2 - (progressInPercent / 100));
    550551                retTime = DateTime.Now.AddSeconds(restSeconds);
  • trunk/CrypPlugins/PeerToPeerManager_NEW/P2PManager_KeyPattern.cs

    r1434 r1448  
    3131using System.Windows.Media;
    3232using Cryptool.Plugins.PeerToPeer.Internal;
     33using System.Numerics;
    3334
    3435/*TODO:
     
    306307                    ((P2PManagerPresentation)QuickWatchPresentation).txtTotal.Text = "" + jobsTotalAmount.ToString();
    307308                    ((P2PManagerPresentation)QuickWatchPresentation).txtInProgress.Text = "" + jobsInProgress.ToString();
    308                     ((P2PManagerPresentation)QuickWatchPresentation).txtLeft.Text = "" + new BigInteger((jobsTotalAmount - jobsInProgress - jobsFinished)).ToString();
     309                    ((P2PManagerPresentation)QuickWatchPresentation).txtLeft.Text = "" + (jobsTotalAmount - jobsInProgress - jobsFinished).ToString();
    309310                    ((P2PManagerPresentation)QuickWatchPresentation).txtFinished.Text = "" + jobsFinished.ToString();
    310311
     
    353354        {
    354355            // new Progress Chunk - Arnold 2010.02.23
    355             if (jobId.LongValue() <= Int32.MaxValue)
    356             {
    357                 int iJobId = (int)jobId.LongValue();
     356            if ((long)jobId <= Int32.MaxValue)
     357            {
     358                int iJobId = (int)jobId;
    358359                if (QuickWatchPresentation.IsVisible)
    359360                {
     
    377378        private void SetProgressChunkJobCount(BigInteger bigInteger)
    378379        {
    379             if (bigInteger.LongValue() <= Int32.MaxValue)
    380             {
    381                 int count = (int)bigInteger.LongValue();
     380            if ((long)bigInteger <= Int32.MaxValue)
     381            {
     382                int count = (int)bigInteger;
    382383                if (QuickWatchPresentation.IsVisible)
    383384                {
  • trunk/CrypPlugins/PeerToPeerManager_NEW/PeerToPeerManager_NEW.csproj

    r1433 r1448  
    104104      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    105105    </Reference>
     106    <Reference Include="System.Numerics" />
    106107    <Reference Include="System.Xaml" />
    107108    <Reference Include="System.Xml.Linq">
  • trunk/CrypPlugins/PeerToPeerWorker_NEW/IControlWorker.cs

    r1139 r1448  
    2020using Cryptool.Plugins.PeerToPeer.Jobs;
    2121using Cryptool.PluginBase.Miscellaneous;
     22using System.Numerics;
    2223
    2324namespace Cryptool.PluginBase.Control
  • trunk/CrypPlugins/PeerToPeerWorker_NEW/P2PJobAdminBase.cs

    r1433 r1448  
    2424using System.Timers;
    2525using Cryptool.Plugins.PeerToPeer.Internal;
     26using System.Numerics;
    2627
    2728/* TWO DIFFERENT STOPPING CASE:
     
    189190                this.timerWaitingForJobs.Stop(); //when receiving a new job, time can be stopped
    190191
    191                 BigInteger jobId = null;
     192                BigInteger jobId = 0;
    192193                GuiLogging("Received a JobPart from '" + senderId.ToString() + "'", NotificationLevel.Debug);
    193194                byte[] serializedRawJobPartData = JobMessages.GetJobPartMessage(data, out jobId);
  • trunk/CrypPlugins/PeerToPeerWorker_NEW/PeerToPeerJobAdmin.csproj

    r1433 r1448  
    108108      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    109109    </Reference>
     110    <Reference Include="System.Numerics" />
    110111    <Reference Include="System.Xaml" />
    111112    <Reference Include="System.Xml.Linq">
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSieve.cs

    r1445 r1448  
    3030using System.Windows;
    3131using System.Reflection;
     32using System.Numerics;
    3233
    3334namespace Cryptool.Plugins.QuadraticSieve
     
    211212                    for (int i = 0; i < factors.Count; i++)
    212213                    {
    213                         outs[i] = new BigInteger((string)factors[i], 10);
     214                        outs[i] = BigInteger.Parse((string)factors[i]);
    214215                    }
    215216                    OutputFactors = outs;
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSieve.csproj

    r1416 r1448  
    111111      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    112112    </Reference>
     113    <Reference Include="System.Numerics" />
    113114    <Reference Include="System.Xaml" />
    114115    <Reference Include="System.Xml.Linq">
  • trunk/CrypPlugins/RSA/RSA.cs

    r1029 r1448  
    2626using System.Threading;
    2727using System.Collections;
     28using System.Numerics;
    2829
    2930namespace Cryptool.Plugins.RSA
     
    117118            //calculate the BigIntegers
    118119            try{
    119                 if (this.InputN is object && this.InputED is object && this.InputMC is object && !stopped)   
    120                     this.OutputMC = InputMC.modPow(this.InputED, this.InputN);
     120                if (this.InputN != 0 && this.InputED != 0 && this.InputMC != 0 && !stopped)
     121                    this.OutputMC = BigInteger.ModPow(InputMC, this.InputED, this.InputN);
    121122            }
    122123            catch (Exception ex)
     
    128129            // RSA on Texts
    129130            //
    130             if (this.InputText is object && this.InputN is object && this.InputED is object && !stopped)
     131            if (this.InputText is object && this.InputN != 0 && this.InputED != 0 && !stopped)
    131132            {
    132133                DateTime startTime = DateTime.Now;
     
    141142                if (settings.Action == 0)
    142143                {
    143                     blocksize_input = (int)Math.Floor(this.InputN.log(256));
    144                     blocksize_output = (int)Math.Ceiling(this.InputN.log(256));
     144                    blocksize_input = (int)Math.Floor(BigInteger.Log(InputN, 256));
     145                    blocksize_output = (int)Math.Ceiling(BigInteger.Log(InputN, 256));
    145146                }
    146147                //Decryption
    147148                else
    148149                {
    149                     blocksize_input = (int)Math.Ceiling(this.InputN.log(256));
    150                     blocksize_output = (int)Math.Floor(this.InputN.log(256));
     150                    blocksize_input = (int)Math.Ceiling(BigInteger.Log(InputN, 256));
     151                    blocksize_output = (int)Math.Floor(BigInteger.Log(InputN, 256));
    151152                }
    152153
     
    387388
    388389                    //create a big integer from a block
    389                     byte[] help = new byte[blocksize_input];
     390                    byte[] help = new byte[blocksize_input+1];
    390391                    for (int j = 0; j < blocksize_input; j++)
    391392                    {
     
    394395                        if (stopped)
    395396                            return;
    396 
    397397                    }
    398398                    bint = new BigInteger(help);
     
    408408
    409409                    //here we encrypt/decrypt with rsa algorithm
    410                     bint = bint.modPow(this.InputED, this.InputN);
     410                    bint = BigInteger.ModPow(bint, this.InputED, this.InputN);
    411411
    412412                    //create a block from the byte array of the BigInteger
    413                     byte[] bytes = bint.getBytes();
     413                    byte[] bytes = removeZeros(bint.ToByteArray());
    414414                    int diff = (blocksize_output - (bytes.Length % blocksize_output)) % blocksize_output;
    415415
    416416                    for (int j = 0; j < bytes.Length; j++)
    417417                    {
    418                         output[i * blocksize_output + j + diff] = bytes[j];
     418                        output[i * blocksize_output + j/* + diff*/] = bytes[j];
    419419                        if (stopped)
    420420                            return;
  • trunk/CrypPlugins/RSA/RSA.csproj

    r1416 r1448  
    108108      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    109109    </Reference>
     110    <Reference Include="System.Numerics" />
    110111    <Reference Include="System.Xaml" />
    111112    <Reference Include="System.Xml.Linq">
  • trunk/CrypPlugins/RSA/RSAKeyGenerator.cs

    r944 r1448  
    2525using System.Security.Cryptography;
    2626using System.Security.Cryptography.X509Certificates;
    27 
     27using System.Numerics;
    2828
    2929namespace Cryptool.Plugins.RSA
     
    171171                    try
    172172                    {
    173                         p = BigInteger.parseExpression(settings.P);
    174                         q = BigInteger.parseExpression(settings.Q);
    175                         e = BigInteger.parseExpression(settings.E);
    176 
    177                         if (!p.isProbablePrime())
     173                        p = BigIntegerHelper.parseExpression(settings.P);
     174                        q = BigIntegerHelper.parseExpression(settings.Q);
     175                        e = BigIntegerHelper.parseExpression(settings.E);
     176
     177                        if (!BigIntegerHelper.isProbablePrime(p))
    178178                        {
    179179                            GuiLogMessage(p.ToString() + " is not prime!", NotificationLevel.Error);
    180180                            return;
    181181                        }
    182                         if (!q.isProbablePrime())
     182                        if (!BigIntegerHelper.isProbablePrime(q))
    183183                        {
    184184                            GuiLogMessage(q.ToString() + " is not prime!", NotificationLevel.Error);
     
    199199                    try
    200200                    {
    201                         D = e.modInverse((p - 1) * (q - 1));
     201                        D = BigIntegerHelper.ModInverse(e, (p - 1) * (q - 1));
    202202                    }
    203203                    catch (Exception)
     
    221221                    try
    222222                    {
    223                         n = BigInteger.parseExpression(settings.N);
    224                         d = BigInteger.parseExpression(settings.D);
    225                         e = BigInteger.parseExpression(settings.E);
     223                        n = BigIntegerHelper.parseExpression(settings.N);
     224                        d = BigIntegerHelper.parseExpression(settings.D);
     225                        e = BigIntegerHelper.parseExpression(settings.E);
    226226                    }
    227227                    catch (Exception ex)
     
    318318                                D = new BigInteger(par.D);
    319319                            else
    320                                 D = null;
     320                                D = 0;
    321321                        }
    322322                        catch (Exception ex)
Note: See TracChangeset for help on using the changeset viewer.