source: trunk/CrypPlugins/DiscreteLogarithm/DiscreteLogarithm.cs @ 1933

Last change on this file since 1933 was 1933, checked in by Sven Rech, 11 years ago

Some index-calculus-algorithm fixes (still doesn't work very good yet :( )

File size: 9.3 KB
Line 
1/*                             
2   Copyright 2010 Team CrypTool (Sven Rech), Uni Duisburg-Essen
3
4   Licensed under the Apache License, Version 2.0 (the "License");
5   you may not use this file except in compliance with the License.
6   You may obtain a copy of the License at
7
8       http://www.apache.org/licenses/LICENSE-2.0
9
10   Unless required by applicable law or agreed to in writing, software
11   distributed under the License is distributed on an "AS IS" BASIS,
12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   See the License for the specific language governing permissions and
14   limitations under the License.
15*/
16
17using System;
18using System.Collections.Generic;
19using System.Linq;
20using System.Text;
21using Cryptool.PluginBase;
22using Cryptool.PluginBase.Miscellaneous;
23using System.ComponentModel;
24using System.Security.Cryptography;
25using System.Threading;
26using System.Collections;
27using System.Numerics;
28using Cryptool.PluginBase.IO;
29using DiscreteLogarithm;
30
31namespace Cryptool.Plugins.DiscreteLogarithm
32{
33    [Author("Sven Rech", null, "Uni Duisburg-Essen", "http://www.uni-due.de")]
34    [PluginInfo(false, "Discrete Logarithm", "Calculates the discrete logarithm", null, "DiscreteLogarithm/icon.png")]
35    /// <summary>
36    /// This plugin calculates the discrete logarithm of the input.
37    /// The input contains of a the BigInteger value and base and the modulo value to determine the residue class
38    /// </summary>
39    class DiscreteLogarithm : IThroughput
40    {
41        #region private members
42
43        private DiscreteLogarithmSettings settings = new DiscreteLogarithmSettings();
44        private BigInteger inputValue;
45        private BigInteger inputBase;
46        private BigInteger inputMod;
47        private BigInteger outputLogarithm;
48        private bool running;
49
50        #endregion
51
52        #region events
53
54        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
55        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
56        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
57        public event StatusChangedEventHandler OnPluginStatusChanged;
58
59        #endregion
60
61        #region public
62       
63        /// <summary>
64        /// Notify that a property changed
65        /// </summary>
66        /// <param name="name">property name</param>
67        public void OnPropertyChanged(string name)
68        {
69            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
70        }
71
72        /// <summary>
73        /// Gets/Sets the Settings of this plugin
74        /// </summary>
75        public ISettings Settings
76        {
77            get { return this.settings; }
78            set { this.settings = (DiscreteLogarithmSettings)value; }
79        }
80
81        /// <summary>
82        /// Get the Presentation of this plugin
83        /// </summary>
84        public System.Windows.Controls.UserControl Presentation
85        {
86            get { return null; }
87        }
88
89        /// <summary>
90        /// Get the QuickWatchRepresentation of this plugin
91        /// </summary>
92        public System.Windows.Controls.UserControl QuickWatchPresentation
93        {
94            get { return null; }
95        }
96
97        /// <summary>
98        /// Called by the environment before execution
99        /// </summary>
100        public void PreExecution()
101        {
102        }
103
104        /// <summary>
105        /// Called by the environment to execute this plugin
106        /// </summary>
107        public void Execute()
108        {
109            running = true;
110
111            if (inputMod.IsZero || inputMod.IsOne)
112            {
113                GuiLogMessage("Input modulo not valid!", NotificationLevel.Error);
114                return;
115            }
116
117            inputBase %= inputMod;
118            if (inputBase.IsZero || inputBase.IsOne)
119            {
120                GuiLogMessage("Input base not valid!", NotificationLevel.Error);
121                return;
122            }
123
124            inputValue %= inputMod;
125            if (inputValue.IsZero)
126            {
127                GuiLogMessage("Input value not valid!", NotificationLevel.Error);
128                return;
129            }
130
131            switch (settings.Algorithm)
132            {
133                case 0:
134                    Enumeration();
135                    break;
136                case 1:
137                    IndexCalculus();
138                    break;
139            }
140        }
141
142        private void IndexCalculus()
143        {
144            //TODO: Make index calculus method stoppable ;)
145            IndexCalculusMethod ic = new IndexCalculusMethod();
146            try
147            {
148                BigInteger res = ic.DiscreteLog(inputValue, inputBase, inputMod);
149                OutputLogarithm = res;
150            }
151            catch (Exception ex)
152            {
153                GuiLogMessage("Index-Calculus error: " + ex.Message, NotificationLevel.Error);
154            }
155        }
156
157        private void Enumeration()
158        {
159            BigInteger t = inputBase;
160            BigInteger counter = 1;
161            while (t != 1 && t != inputValue && running)
162            {
163                t = (t * inputBase) % inputMod;
164                counter++;
165            }
166
167            if (!running)
168                return;
169
170            if (t == inputValue)
171                OutputLogarithm = counter;
172            else
173                GuiLogMessage("Input base not a generator of given residue class", NotificationLevel.Error);
174        }
175
176        /// <summary>
177        /// Called by the environment after execution of this plugin
178        /// </summary>
179        public void PostExecution()
180        {
181        }
182
183        /// <summary>
184        /// Called by the environment to pause this plugin
185        /// </summary>
186        public void Pause()
187        {
188        }
189
190        /// <summary>
191        /// Called by the environment to stop this plugin
192        /// </summary>
193        public void Stop()
194        {
195            running = false;
196        }
197
198        /// <summary>
199        /// Called by the environment to initialize this plugin
200        /// </summary>
201        public void Initialize()
202        {
203        }
204
205        /// <summary>
206        /// Called by the environment to Dispose this plugin
207        /// </summary>
208        public void Dispose()
209        {
210
211        }
212
213        /// <summary>
214        /// Gets/Sets the value x in b^log_b(x) = x
215        /// </summary>
216        [PropertyInfo(Direction.InputData, "Input value", "Enter your input value here", "", DisplayLevel.Beginner)]
217        public BigInteger InputValue
218        {
219            get
220            {
221                return inputValue;
222            }
223            set
224            {
225                inputValue = value;
226                OnPropertyChanged("InputValue");
227            }
228        }
229
230        /// <summary>
231        /// Gets/Sets the base b in b^log_b(x) = x
232        /// </summary>
233        [PropertyInfo(Direction.InputData, "Input base/generator", "Enter your base/generator here", "", DisplayLevel.Beginner)]
234        public BigInteger InputBase
235        {
236            get
237            {
238                return inputBase;
239            }
240            set
241            {
242                inputBase = value;
243                OnPropertyChanged("InputBase");
244            }
245        }
246
247        /// <summary>
248        /// Gets/Sets the modulo value for the used residue class
249        /// </summary>
250        [PropertyInfo(Direction.InputData, "Input modulo", "Enter your modulo here", "", DisplayLevel.Beginner)]
251        public BigInteger InputMod
252        {
253            get
254            {
255                return inputMod;
256            }
257            set
258            {
259                inputMod = value;
260                OnPropertyChanged("InputMod");
261            }
262        }
263
264        /// <summary>
265        /// Gets/Sets the calculated discrete logarithm
266        /// </summary>
267        [PropertyInfo(Direction.OutputData, "discrete logarithm output", "Get the result here!", "", DisplayLevel.Beginner)]
268        public BigInteger OutputLogarithm
269        {
270            get
271            {
272                return outputLogarithm;
273            }
274            set
275            {
276                outputLogarithm = value;
277                OnPropertyChanged("OutputLogarithm");
278            }
279        }
280       
281
282        #endregion
283
284        #region private
285
286        /// <summary>
287        /// Change the progress of this plugin
288        /// </summary>
289        /// <param name="value">value</param>
290        /// <param name="max">max</param>
291        private void ProgressChanged(double value, double max)
292        {
293            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
294        }
295
296        /// <summary>
297        /// Logg a message to cryptool
298        /// </summary>
299        /// <param name="p">p</param>
300        /// <param name="notificationLevel">notificationLevel</param>
301        private void GuiLogMessage(string p, NotificationLevel notificationLevel)
302        {
303            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(p, this, notificationLevel));
304        }
305
306        #endregion
307
308    }//end DiscreteLogarithm
309
310}//end Cryptool.Plugins.DiscreteLogarithm
Note: See TracBrowser for help on using the repository browser.