Changeset 8407


Ignore:
Timestamp:
Oct 11, 2019, 1:01:56 AM (2 years ago)
Author:
Simon Leischnig
Message:

Plugin: LFSR: Introduced control of shift-in direction of seed bitstring

  • fixed one and a half bug
  • added short explanation in the help files for new outputs.
  • Updated LFSR template file
Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPluginBase/Utils/ObjectDeconstruct.cs

    r8406 r8407  
    2121using System.Threading.Tasks;
    2222using System.Reflection;
    23 using System.Text;
    2423
    2524namespace Cryptool.PluginBase.Utils
  • trunk/CrypPlugins/LFSR/Core/LFSRImplementation.cs

    r8406 r8407  
    9393            OnRoundStarting();
    9494            var poly = Fun.ToPoly(InputPoly.Value);
    95             var taps = Fun.ToSeed(InputSeed.Value);
     95            var taps = Fun.ToSeed(InputSeed.Value, Parameters.SeedFlipped);
    9696            Fun.ValidateNonrecurrentParams((poly, taps));
    9797
     
    129129                if (!this.Parameters.UseClock)
    130130                {
     131                    // self-propell with a rising clock edge if no external clock is present
    131132                    this.internalClk.Value = false;
    132133                    this.internalClk.Value = true;
     
    164165        public Parameter<bool> UseClock = new Parameter<bool>(false);
    165166        public Parameter<bool> DisablePresentation = new Parameter<bool>(false);
     167        public Parameter<bool> SeedFlipped = new Parameter<bool>(true);
    166168    }
    167169
     
    351353                    {
    352354                        hasMathMatch = true;
     355                        if (lastBoolMatchPos > -1) throw new LFSRInputInvalidException(InputInvalidReason.MixedPolyFormat);
    353356                        positions.Add((Convert.ToInt32(match.Groups[1].Value), true));
    354357                    }
     
    358361                        if (match.Success)
    359362                        {
     363                            if (hasMathMatch) throw new LFSRInputInvalidException(InputInvalidReason.MixedPolyFormat);
    360364                            lastBoolMatchPos++;
    361365                            positions.Add((Convert.ToInt32(lastBoolMatchPos), match.Groups[0].Value == "0" ? false : true));
     
    391395                return new Polynom(result);
    392396            }
    393             public static ShiftReg ToSeed(String seed)
     397
     398            public static ShiftReg ToSeed(String seed, bool flipped)
    394399            {
    395400                var noWhitespace = RemoveWhitespace(seed);
     
    410415                    }
    411416                }
    412                 result.Reverse();
     417                // if the seed is read in flipped (in reverse direction of the screen)
     418                if (flipped)
     419                {
     420                    result.Reverse();
     421                }
     422
    413423                return new ShiftReg(result);
    414424            }
     
    467477            PolyDoublePos,
    468478            PolyIsUnset,
    469             SeedIsUnset
     479            SeedIsUnset,
     480            MixedPolyFormat
    470481        }
    471482
     
    546557                    case InputInvalidReason.IsNoBitstring:
    547558                        inputName = seed;
    548                         return string.Format("{0} Input is no bitstring", inputName);
     559                        return string.Format("{0} Input is no bitstring.", inputName);
    549560                    case InputInvalidReason.RightmostBitNotOne:
    550561                        inputName = poly;
    551562                        return string.Format("{0} Input is no valid tap sequence. The rightmost tap bit must be one.", inputName);
    552563                    case InputInvalidReason.BitstringsNotSameLength:
    553                         return string.Format("The two inputs must have the same length");
     564                        return string.Format("The two inputs must have the same length.");
    554565                    case InputInvalidReason.ClockTooFast:
    555566                        return string.Format("The clock input changed too fast - the shift register was still calculating feedback.");
    556567                    case InputInvalidReason.PolyIsEmpty:
    557568                        inputName = poly;
    558                         return string.Format("{0} Input is empty", inputName);
     569                        return string.Format("{0} Input is empty.", inputName);
    559570                    case InputInvalidReason.SeedIsEmpty:
    560571                        inputName = seed;
    561                         return string.Format("{0} Input is empty", inputName);
     572                        return string.Format("{0} Input is empty.", inputName);
    562573                    case InputInvalidReason.PolyDoublePos:
    563574                        inputName = poly;
    564575                        return string.Format("{0} Input is not well-formed. Reason: Doubly-defined tap position.", inputName);
     576                    case InputInvalidReason.MixedPolyFormat:
     577                        return string.Format("Polynom input has as well tap-sequence (0/1) as well as power-of-x notation parts which may not be mixed.");
    565578                    default:
    566                         return string.Format("Some error with the Inputs of the Component occured", e.context);
     579                        return string.Format("Some error with the Inputs of the Component occured.", e.context);
    567580                }
    568581            }
    569582            else
    570583            {
    571                 return ex.ToString();
     584                return ex.Message;
    572585            }
    573586        }
  • trunk/CrypPlugins/LFSR/DetailedDescription/doc.xml

    r7480 r8407  
    77    The LFSR component implements the functionality of a linear feedback shift register. Given a polynomial and a seed, it computes as many output bits as set in the settings of the plugin.
    88    Additionally the plugin displays a visual live representation of the LFSR in its presentation. Moreover the plugin can be stepped by an external clock.
    9     To get a specific internal stage the LFSR plugin also provides an additional output bit. The stage is marked orange in the presentation.
    10     If all stages are needed, the plugin is able to provide a boolean array that outputs the complete state of an LFSR.<newline /><newline /><img src="LFSR/DetailedDescription/Images/LFSR.png" /></introduction>
     9    If all stages are needed, the plugin is able to provide a boolean array that outputs the complete state of an LFSR. These internal states can be given as the current state in form of an array of bool values, as well as strings. Two string outputs are available, that show the current and as well all past internal states.<newline /><newline />
     10   
     11    Of particular interest should be, when following examples from literature, to set the correct read-in order of the seed string. Some literature intends a seed bitstring to be initially shifted into the register with its leftmost bit first, other write them so that the rightmost bit is shifted in first. A dedicated option is available as setting to control this direction of reading in the seed bitstring.<newline /><newline /><img src="LFSR/DetailedDescription/Images/LFSR.png" /></introduction>
    1112  <introduction lang="ru">Компонент LFSR реализует функциональные возможности линейного сдвигового регистра обратной связи. Учитывая многочлен и семя, он вычисляет столько выходных битов, сколько задано в настройках плагина. Кроме того, плагин отображает визуальное живое представление LFSR в своем представлении. Кроме того, плагин может быть наложен на внешние часы. Чтобы получить конкретный внутренний этап, плагин LFSR также предоставляет дополнительный выходной бит. Сцена отмечена оранжевым в презентации. Если все этапы необходимы, плагин может обеспечить булевский массив, который выводит полное состояние LFSR.</introduction>
    1213  <introduction lang="de-DE">
     
    1516    Außerdem stellt die Komponente eine graphische Präsentation der Vorgänge im LFSR dar.
    1617    Weiterhin kann die Komponente mit einem externen Takt geschaltet werden.
    17     Um ein spezielles internes Zustandsbit der Komponente auslesen zu können, wird ein zusätzliches Ausgabebit zur Verfügung gestellt. Das ausgelesene Zustandsbit wird in der Präsentation orange dargestellt.
    18     Falls der gesamte Zustand des Schieberegisters benötigt wird, so können die Zustandsbits an einem weiteren Ausgang der Komponente komplett als ein Bit-Array ausgelesen werden.<newline /><newline /><img src="LFSR/DetailedDescription/Images/LFSR.png" /></introduction>
     18    Falls der gesamte Zustand des Schieberegisters benötigt wird, so können die Zustandsbits an einem weiteren Ausgang der Komponente komplett als ein Bit-Array ausgelesen werden. Diese Möglichkeit besteht sowohl in Form von Boolean-Arrays als auch als (besser lesbare) Zeichenkette aus 0 und 1.<newline /><newline />
     19    Wenn Beispiele aus der Literatur nachvollzogen werden sollen, so muss der Einleserichtung für den Seed Beachtung geschenkt werden: Manche Autoren schreiben die Seed-Bitketten so, dass sie in das Register mit dem linkesten Bit zuerst eingeschoben werden (und dadurch andersherum als in der Eingabe aufgereiht im Register erscheinen), andere Autoren schieben das rechte Bit zuerst hinein. Dafür ist eine Option vorgesehen, die diese Einleserichtung kontrollieren lässt.<newline /><newline /><img src="LFSR/DetailedDescription/Images/LFSR.png" /></introduction>
    1920  <usage lang="en">
    2021    Some scenarios including detailed walkthroughs that describe the usage of the LFSR plugin can be found here:<newline /><external ref="https://www.cryptool.org/ct2download/Tutorials/StreamCipherToolboxScenarios.pdf" /></usage>
  • trunk/CrypPlugins/LFSR/LFSRPlugin.cs

    r8406 r8407  
    3838            Ids = new Dictionary<object, string>()
    3939            {
     40                [api.SeedFlipped] = "SeedFlipped",
    4041                [api.PresentationShift] = "PresentationShift",
    4142                [api.Rounds] = "Rounds",
     
    8485        #endregion
    8586
     87        #region UI binding: api.SeedFlipped <-> NoQuickwatch (attributed property)
     88        [TaskPane(
     89            "SeedFlippedCaption", "SeedFlippedTooltip",
     90            null,
     91            2,
     92            false,
     93            ControlType.CheckBox,
     94            "", null
     95            )]
     96        public bool SeedFlipped { get => api.SeedFlipped; set => api.SeedFlipped.Set(value); }
     97        #endregion
     98
    8699        #region UI binding: api.DisablePresentation <-> NoQuickwatch (attributed property)
    87100        [TaskPane(
     
    225238            var shift = api.Parameters.PresentationShift.Value;
    226239            var currentRound = api.currentRound;
    227             if (currentRound == null)
     240            if (currentRound == null || currentRound.ParentRound.IsNone)
    228241            {
    229242                deletePresentation();
    230243                return;
    231244            }
    232             int effectiveRoundNr = currentRound.RoundNumber - shift - 1;
    233             LFSRRound myRound = currentRound;
    234             while (effectiveRoundNr < myRound.RoundNumber)
    235             {
    236                 if (myRound.ParentRound.IsSome)
     245            var roundThatHasFinished = api.currentRound.ParentRound.Get();
     246            LFSRRound presentationRound = roundThatHasFinished;
     247            while (presentationRound.RoundNumber > roundThatHasFinished.RoundNumber - shift)
     248            {
     249                if (presentationRound.ParentRound.IsSome)
    237250                {
    238                     myRound = myRound.ParentRound.Get();
     251                    presentationRound = presentationRound.ParentRound.Get();
    239252                }
    240253                else
    241254                {
    242                     if (myRound.RoundNumber == 1)
     255                    if (presentationRound.RoundNumber > 1)
    243256                    {
    244                         api.Log("Cannot display an earlier round number than number " + myRound.RoundNumber, LogLevels.Info);
    245                         deletePresentation();
    246                         try
    247                         {
    248                             this.isResettingShift = true; // lock to prevent infinite recursion
    249                             if (api.currentRound == null)
    250                             {
    251                                 api.Parameters.PresentationShift.Value = 0;
    252                             }
    253                             api.Parameters.PresentationShift.Value = Math.Max(0, api.currentRound.RoundNumber-myRound.RoundNumber);
    254                         }
    255                         finally { this.isResettingShift = false; }
     257                        api.Log(String.Format("Rounds earlier round number {0} are not kept in memory.", presentationRound.RoundNumber), LogLevels.Info);
    256258                    }
     259//                     try
     260//                     {
     261//                         this.isResettingShift = true; // lock to prevent infinite recursion
     262//                         api.Parameters.PresentationShift.Value = Math.Max(0, roundThatHasFinished.RoundNumber - presentationRound.RoundNumber);
     263//                     }
     264//                     finally { this.isResettingShift = false; }
     265                    break;
    257266                }
    258267            }
    259             var round = myRound;
    260             List<bool> registerContent = round.RegInitial.Bits;
    261             List<bool> tapSequence = round.Polynom.taps;
    262             Option<bool> output = Some(round.GetShiftOutBit());
    263             bool newBit = round.RegAfter.Bits[0];
    264             this.showPresentation(registerContent, tapSequence, output, newBit, round.RoundNumber);
     268            List<bool> registerContent = presentationRound.RegInitial.Bits;
     269            List<bool> tapSequence = presentationRound.Polynom.taps;
     270            Option<bool> output = Some(presentationRound.GetShiftOutBit());
     271            bool newBit = presentationRound.RegAfter.Bits[0];
     272            this.showPresentation(registerContent, tapSequence, output, newBit, presentationRound.RoundNumber);
    265273        }
    266274
  • trunk/CrypPlugins/LFSR/Properties/Resources.Designer.cs

    r8406 r8407  
    494494       
    495495        /// <summary>
     496        ///   Looks up a localized string similar to Seed: left bit first in.
     497        /// </summary>
     498        public static string SeedFlippedCaption {
     499            get {
     500                return ResourceManager.GetString("SeedFlippedCaption", resourceCulture);
     501            }
     502        }
     503       
     504        /// <summary>
     505        ///   Looks up a localized string similar to The seed is initially shifted into the register with the leftmost bit first (so that it appears in the register in flipped order compared to the input).
     506        /// </summary>
     507        public static string SeedFlippedTooltip {
     508            get {
     509                return ResourceManager.GetString("SeedFlippedTooltip", resourceCulture);
     510            }
     511        }
     512       
     513        /// <summary>
    496514        ///   Looks up a localized string similar to Define the seed (initial state) of the LFSR. For example 11100..
    497515        /// </summary>
  • trunk/CrypPlugins/LFSR/Properties/Resources.de.resx

    r8406 r8407  
    279279  <data name="MaxRecordedRoundsTooltip" xml:space="preserve">
    280280    <value>Maximale Runden für die Ergebnisse zwischengespeichert werden</value>
    281   </data>  <data name="PresentationShiftCaption" xml:space="preserve">
     281  </data>
     282  <data name="PresentationShiftCaption" xml:space="preserve">
    282283    <value>Präsentation um n Runden nach hinten verschieben</value>
    283284  </data>
     
    288289    <value>Runde: </value>
    289290  </data>
     291  <data name="SeedFlippedCaption" xml:space="preserve">
     292    <value>Seed: Linked Bit zuerst</value>
     293  </data>
     294  <data name="SeedFlippedTooltip" xml:space="preserve">
     295    <value>Gibt an, ob der Seed mit dem linken Bit zuerst in das Register eingeschoben wird. Dies führt dazu, dass die Eingabezeichenfolge dieselbe Reihenfolge wie die Bits im Shiftregister haben.</value>
     296  </data>
    290297</root>
  • trunk/CrypPlugins/LFSR/Properties/Resources.resx

    r8406 r8407  
    289289    <value>Round:</value>
    290290  </data>
     291  <data name="SeedFlippedCaption" xml:space="preserve">
     292    <value>Seed: left bit first in</value>
     293  </data>
     294  <data name="SeedFlippedTooltip" xml:space="preserve">
     295    <value>The seed is initially shifted into the register with the leftmost bit first (so that it appears in the register in flipped order compared to the input)</value>
     296  </data>
    291297</root>
Note: See TracChangeset for help on using the changeset viewer.