Changeset 8586


Ignore:
Timestamp:
Jan 29, 2020, 10:48:13 AM (2 years ago)
Author:
Christian Bender
Message:

Speck: small corrections

Location:
trunk/CrypPlugins/Speck
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/Speck/Properties/Resources.Designer.cs

    r8577 r8586  
    2020    // Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen
    2121    // mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu.
    22     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
     22    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
    2323    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    2424    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
  • trunk/CrypPlugins/Speck/Properties/Resources.de.resx

    r8577 r8586  
    227227  </data>
    228228  <data name="Speck_Execute_Key_too_short" xml:space="preserve">
    229     <value>Die Schlüssellänge = {0} ist zu kurz. Notwendige Schlüssellänge beträgt {1} byte.</value>
     229    <value>Die Schlüssellänge = {0} ist zu kurz. Notwendige Schlüssellänge beträgt {1} Byte.</value>
    230230  </data>
    231231  <data name="Speck_no_cryptofunction" xml:space="preserve">
     
    260260  </data>
    261261  <data name="Speck_Input_too_short_singleByte" xml:space="preserve">
    262     <value>Der Eingabestrom ist zu kurz. Es fehlt {0} byte oder es muss ein Padding-Modus ausgewählt werden.</value>
     262    <value>Der Eingabestrom ist zu kurz. Es fehlt {0} Byte oder es muss ein Padding-Modus ausgewählt werden.</value>
    263263  </data>
    264264  <data name="Speck_Input_too_short_multipleByte" xml:space="preserve">
  • trunk/CrypPlugins/Speck/Speck.cs

    r8577 r8586  
    2727{
    2828    [Author("Christian Bender", "christian1.bender@student.uni-siegen.de", null, "http://www.uni-siegen.de")]
    29     [PluginInfo("Speck.Properties.Resources", "PluginCaption", "PluginTooltip", "Speck/userdoc.xml", "Speck/Images/IC_Speck.png")]
     29    [PluginInfo("Speck.Properties.Resources", "PluginCaption", "PluginTooltip", "Speck/userdoc.xml", "Speck/Images/IC_Speck2.png")]
    3030    [ComponentCategory(ComponentCategory.CiphersModernSymmetric)]
    3131    public class Speck : ICrypComponent
     
    427427                            if (settings.OpMode == OperatingMode.Encrypt)
    428428                            {
    429                                 inputBlock = SpeckCiphers.XOR(inputBlock, lastBlock);
     429                                inputBlock = SpeckCiphers.Xor(inputBlock, lastBlock);
    430430                                outputBlock = cryptoFunction(inputBlock, _inputKey);
    431431                                lastBlock = outputBlock;
     
    434434                            {
    435435                                outputBlock = cryptoFunction(inputBlock, _inputKey);
    436                                 outputBlock = SpeckCiphers.XOR(outputBlock, lastBlock);
     436                                outputBlock = SpeckCiphers.Xor(outputBlock, lastBlock);
    437437                                lastBlock = inputBlock;
    438438                            }
     
    446446                                byte[] block = new byte[settings.BlockSize_2n / 8];
    447447                                Array.Copy(inputBlock, 0, block, 0, readcount);
    448                                 inputBlock = SpeckCiphers.XOR(block, lastBlock);
     448                                inputBlock = SpeckCiphers.Xor(block, lastBlock);
    449449                                outputBlock = cryptoFunction(inputBlock, _inputKey);
    450450                            }
     
    452452                            {
    453453                                outputBlock = cryptoFunction(inputBlock, _inputKey);
    454                                 outputBlock = SpeckCiphers.XOR(outputBlock, lastBlock);
     454                                outputBlock = SpeckCiphers.Xor(outputBlock, lastBlock);
    455455                            }
    456456                        }
     
    523523                            {
    524524                                outputblock = cryptoFunction(lastBlock, _inputKey);
    525                                 outputblock = SpeckCiphers.XOR(outputblock, inputBlock);
     525                                outputblock = SpeckCiphers.Xor(outputblock, inputBlock);
    526526                                lastBlock = outputblock;
    527527                            }
     
    529529                            {
    530530                                outputblock = cryptoFunction(lastBlock, _inputKey);
    531                                 outputblock = SpeckCiphers.XOR(outputblock, inputBlock);
     531                                outputblock = SpeckCiphers.Xor(outputblock, inputBlock);
    532532                                lastBlock = inputBlock;
    533533                            }
     
    542542                                Array.Copy(inputBlock, 0, block, 0, readcount);
    543543                                outputblock = cryptoFunction(lastBlock, _inputKey);
    544                                 outputblock = SpeckCiphers.XOR(outputblock, block);
     544                                outputblock = SpeckCiphers.Xor(outputblock, block);
    545545                            }
    546546                            else
     
    549549                                Array.Copy(inputBlock, 0, block, 0, readcount);
    550550                                outputblock = cryptoFunction(inputBlock, _inputKey);
    551                                 outputblock = SpeckCiphers.XOR(outputblock, lastBlock);
     551                                outputblock = SpeckCiphers.Xor(outputblock, lastBlock);
    552552                            }
    553553                        }
     
    620620                                outputblock = cryptoFunction(lastBlock, _inputKey);
    621621                                lastBlock = outputblock;
    622                                 outputblock = SpeckCiphers.XOR(outputblock, inputBlock);
     622                                outputblock = SpeckCiphers.Xor(outputblock, inputBlock);
    623623                            }
    624624                            else
     
    626626                                outputblock = cryptoFunction(lastBlock, _inputKey);
    627627                                lastBlock = outputblock;
    628                                 outputblock = SpeckCiphers.XOR(outputblock, inputBlock);
     628                                outputblock = SpeckCiphers.Xor(outputblock, inputBlock);
    629629                            }
    630630                        }
     
    638638                                Array.Copy(inputBlock, 0, block, 0, readcount);
    639639                                outputblock = cryptoFunction(lastBlock, _inputKey);
    640                                 outputblock = SpeckCiphers.XOR(outputblock, block);
     640                                outputblock = SpeckCiphers.Xor(outputblock, block);
    641641                            }
    642642                            else
     
    645645                                Array.Copy(inputBlock, 0, block, 0, readcount);
    646646                                outputblock = cryptoFunction(inputBlock, _inputKey);
    647                                 outputblock = SpeckCiphers.XOR(outputblock, lastBlock);
     647                                outputblock = SpeckCiphers.Xor(outputblock, lastBlock);
    648648                            }
    649649                        }
  • trunk/CrypPlugins/Speck/Speck.csproj

    r8555 r8586  
    124124    <Resource Include="Images\IC_Speck.png" />
    125125  </ItemGroup>
     126  <ItemGroup>
     127    <Resource Include="Images\IC_Speck2.png" />
     128  </ItemGroup>
    126129  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
    127130  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
  • trunk/CrypPlugins/Speck/SpeckCiphers.cs

    r8572 r8586  
    17711771        /// <param name="a"></param>
    17721772        /// <param name="b"></param>
    1773         public static byte[] XOR(byte[] a, byte[] b)
     1773        public static byte[] Xor(byte[] a, byte[] b)
    17741774        {
    17751775            byte[] c = new byte[a.Length];
  • trunk/CrypPlugins/Speck/userdoc.xml

    r8580 r8586  
    66        <language culture="de-DE"/>
    77        <introduction lang="en">
    8                 Speck is a so-called "Lightweight Block Cipher", which was developed by the american National Security Agency (NSA) and published in 2013 <ref id="SpeckPaper" />. Lightweight Ciphers require less computing capacity compared to ordinary block ciphers.
     8                Speck is a so-called "Lightweight Block Cipher", which was developed by the American National Security Agency (NSA) and published in 2013 <ref id="SpeckPaper" />. Lightweight Ciphers require less computing capacity compared to ordinary block ciphers.
    99                Besides Speck, the cipher Simon belongs to the same family of ciphers. Speck is optimized for software implementations and Simon for hardware implementations. Speck is an ARX (add-rotate-xor) cipher. <newline /><newline />
    10                 Speck consists of a large number of different varieties. These differ in block and key length. Thus Speck can be used on a large number of different devices (in different performance categories).
     10                Speck consists of a big number of different varieties. These differ in block and key length. Thus Speck can be used on a large number of different devices (in different performance categories).
    1111                The different variants offer different security levels. Speck can also be used on devices and environments where an AES would be unsuitable (e.g. an insulin pump). <newline /><newline />
    12                 The block length can be 32, 48, 64, 96 and 128 bits, whereby the 64 and 128 bit variants are the most common block lengths <ref id="SpeckImplGuide" />. Depending on the block length different key lengths are possible. For example, the 32 bit variant works with 64 bit key length,
    13                 for the variant with 128 bit block length, 128, 192 and 256 bit long keys can be selected <newline /><newline />
    14                 Within Speck, an input block is divided into words that are always half as long as a block. The key is also divided into words. Depending on the selected parameterization of Speck, it is divided into 2-4 keywords. The basic operations are addition, (bit) rotation (= cyclic bit shift) and XOR.
     12                The block length can be 32, 48, 64, 96, and 128 bits, whereby the 64 and 128 bit variants are the most common block lengths <ref id="SpeckImplGuide" />. Depending on the block length different key lengths are possible. For example, the 32 bit variant works with 64 bit key length;
     13                for the variant with 128 bit block length, 128, 192 and 256 bit keys can be selected <newline /><newline />
     14                Within Speck, an input block is divided into words that are always half as long as a block. The key is also divided into words. The key is also divided into words. Depending on the selected parameterization, a key is divided into 2-4 keywords. The basic operations are addition, (bit) rotation (= cyclic bit shift), and XOR.
    1515        </introduction>
    1616
    1717        <usage lang="en">
    1818                <section headline="Speck parameterization">
    19                 The different variants of Speck can be configured in the component settings. These are specified in the form "Speck x/y", where x is the block length and y the key length in bits.
     19                The different variants of Speck can be configured in the component settings. These are specified in the form "Speck x/y", where x is the block length and y is the key length in bits.
    2020                </section>
    2121                <section headline="Encryption / Decryption">
     
    2323                </section>
    2424                <section headline="Operating mode">
    25                 The Speck component offers four different operating modes for linking blocks. These are ECB (Electronic Code Book), CBC (Cipher Block Chaining), CFB (Cipher Feedback) and OFB (Output Feedback). These can be selected in the component settings.
     25                The Speck component offers four different operating modes for linking blocks: ECB (Electronic Code Book), CBC (Cipher Block Chaining), CFB (Cipher Feedback), and OFB (Output Feedback). These can be selected in the component settings.
    2626                </section>
    2727                <section headline="Padding">
    28                 If the input does not contain a complete block, it can be extended to the required block length. The Speck component offers five different padding methods for this purpose. These are Zeros, PKCS7, ANSIX923, ISO10126 and 1-0 padding.
     28                If the input does not contain a complete block, it is extended to the required block length. The Speck component offers five different padding methods for this purpose: Zeros, PKCS7, ANSIX923, ISO10126, and 1-0 padding.
    2929                </section>
    3030        </usage>
    3131
    3232        <introduction lang="de-DE">
    33                 Speck ist eine so genannte leichtgewichte symmetrische Blockchiffre ("Lightweight Block Cipher"), die von vom amerikanischen Geheimdienst National Security Agency (NSA) entwickelt und 2013 veröffentlicht <ref id="SpeckPaper" /> wurde. Leichtgewichtige Chiffren
    34                 benötigen im Vergleich zu gewöhnlichen Blochchiffren weniger Rechenkapazität. Neben Speck gehört die Chiffre Simon zur selben Familie von Chiffren. Speck ist optimiert für Software-Implementierungen und Simon für Hardware-Implementierungen. Speck ist eine ARX (add–rotate–xor) Chiffre. <newline /><newline />
     33                Speck ist eine sogenannte leichtgewichte symmetrische Blockchiffre ("Lightweight Block Cipher"), die von vom amerikanischen Geheimdienst National Security Agency (NSA) entwickelt und 2013 veröffentlicht <ref id="SpeckPaper" /> wurde. Leichtgewichtige Chiffren
     34                benötigen im Vergleich zu gewöhnlichen Blockchiffren weniger Rechenkapazität. Neben Speck gehört die Chiffre Simon zur selben Familie von Chiffren. Speck ist optimiert für Software-Implementierungen und Simon für Hardware-Implementierungen. Speck ist eine ARX-Chiffre (add-rotate-xor). <newline /><newline />
    3535                Speck besteht aus einer großen Anzahl von verschiedenen Varianten. Diese unterscheiden sich in der Block- und Schlüssellänge. So kann Speck auf einer Vielzahl von verschiedenen Geräten (in verschiedenen Leistungskategorien) eingesetzt werden.
    36                 Die verschiedenen Varianten bieten unterschiedliche Sicherheitslevel. Speck kann auch auf Geräten und Umgebungen eingesetzt werden, wo ein AES beispielsweise ungeeignet wäre (z.B. eine Insulinpumpe). <newline /><newline />
    37                 Als Blocklänge sind 32, 48, 64, 96 und 128 Bit möglich, wobei die Varianten mit 64 und 128 Bit die gängisten Blocklängen sind <ref id="SpeckImplGuide" />. Je nach Blocklänge sind verschiedene Schlüssellängen möglich. So arbeitet die 32 Bit Variante mit 64 Bit Schlüssellänge,
     36                Die verschiedenen Varianten bieten unterschiedliche Sicherheitslevel. Speck kann auch auf Geräten und Umgebungen eingesetzt werden, wo beispielsweise ein AES ungeeignet wäre (z.B. eine Insulinpumpe). <newline /><newline />
     37                Als Blocklänge sind 32, 48, 64, 96 und 128 Bit möglich, wobei die Varianten mit 64 und 128 Bit die gängigsten Blocklängen sind <ref id="SpeckImplGuide" />. Je nach Blocklänge sind verschiedene Schlüssellängen möglich. So arbeitet die 32 Bit Variante mit 64 Bit Schlüssellänge;
    3838                bei der Variante mit 128 Bit Blocklänge sind 128, 192 und 256 Bit lange Schlüssel wählbar. <newline /><newline />
    39                 Innerhalb von Speck wird ein Eingabeblock in Worte aufgeteilt, die immer halb so lang wie ein Block sind. Der Schlüssel wird ebenfalls in Worte aufgeteilt. Je nach gewählter Parametrisierung von Speck wird dieser in 2-4 Schlüsselworte geteilt. Die Basisoperationen sind Addition, (Bit-) Rotation (= zyklischer Bitshift) und XOR.
     39                Innerhalb von Speck wird ein Eingabeblock in Worte aufgeteilt, die immer halb so lang wie ein Block sind. Der Schlüssel wird ebenfalls in Worte aufgeteilt. Je nach gewählter Parametrisierung von Speck wird dieser in 2-4 Schlüsselworte geteilt. Die Basisoperationen sind Addition, (Bit-)Rotation (= zyklischer Bitshift) und XOR.
    4040        </introduction>
    4141
     
    4343        <usage lang="de-DE">
    4444                <section headline="Speck-Parametrisierung">
    45                 Die verschiedenen Varianten von Speck können in den Einstellungen der Komponente konfiguriert werden. Diese werden in der Form "Speck x/y" angegeben, wobei x die Blocklänge und y die Schlüssellänge in Bits angbit.
     45                Die verschiedenen Varianten von Speck können in den Einstellungen der Komponente konfiguriert werden. Diese werden in der Form "Speck x/y" angegeben, wobei x die Blocklänge und y die Schlüssellänge in Bits angibt.
    4646                </section>
    4747                <section headline="Verschlüsselung / Entschlüsselung">
     
    4949                </section>
    5050                <section headline="Betriebsmodus">
    51                 Die Speck-Komponente bietet zur Verkettung von Blöcken vier verschiedene Betriebsmodi an. Diese sind ECB (Electronic Code Book), CBC (Cipher Block Chaining), CFB (Cipher Feedback) und OFB (Output Feedback). Diese können in den Einstellungen der Komponente ausgewählt werden.
     51                Die Speck-Komponente bietet zur Verkettung von Blöcken vier verschiedene Betriebsmodi an: ECB (Electronic Code Book), CBC (Cipher Block Chaining), CFB (Cipher Feedback) und OFB (Output Feedback). Diese können in den Einstellungen der Komponente ausgewählt werden.
    5252                </section>
    5353                <section headline="Padding">
    54                 Enthält die Eingabe keinen vollständigen Block, so kann dieser auf die notwendige Blocklänge verlängert werden. Die Speck-Komponente bietet dazu fünf verschiedene Padding-Verfahren an. Diese sind Zeros, PKCS7, ANSIX923, ISO10126 und 1-0 Padding.
     54                Enthält die Eingabe keinen vollständigen Block, so wird dieser auf die notwendige Blocklänge verlängert. Die Speck-Komponente bietet dazu fünf verschiedene Padding-Verfahren an: Zeros, PKCS7, ANSIX923, ISO10126 und 1-0 Padding.
    5555                </section>
    5656        </usage>
     
    5959                <linkReference id="SpeckPaper">
    6060                        <link url="https://eprint.iacr.org/2013/404.pdf" lang="en" />
    61                         <caption lang="en">The Simon And Speck Families Of Lightweight Block Ciphers</caption>
     61                        <caption lang="en">The Simon and Speck Families of Lightweight Block Ciphers</caption>
    6262                        <link url="https://eprint.iacr.org/2013/404.pdf" lang="de-DE" />
    63                         <caption lang="de-DE">The Simon And Speck Families Of Lightweight Block Ciphers</caption>
     63                        <caption lang="de-DE">The Simon and Speck Families of Lightweight Block Ciphers</caption>
    6464                </linkReference>
    6565                <linkReference id="SpeckIOT">
Note: See TracChangeset for help on using the changeset viewer.