Zurück
Testvektoren für die T-310; BStU*442
Die Umsetzung in C in Anwendung der folgenden Beschreibung.

Der verwendete LZS ist die №:31
P  =  (7, 4, 33, 30, 18, 36, 5, 35, 9, 16, 23, 26, 32, 12,
       21, 1, 13, 25, 20, 8, 24, 15, 22, 29, 10, 28, 6)
D  =  (0, 16, 4, 24, 12, 28, 32, 36, 20)
α  =  2

Damit ergibt sich folgendes Gleichungssystem für die Abbildung
φ(s1, s2, f) :

Y1  = s1  + f + Z0 + u36 + Z1 + u32 + s2 + Z2 + u8 + Z3 + u6
Y5  = u16 + f + Z0 + u36 + Z1 + u32 + s2 + Z2 + u8 + Z3
Y9  = u4  + f + Z0 + u36 + Z1 + u32 + s2 + Z2 + u8
Y13 = u24 + f + Z0 + u36 + Z1 + u32 + s2 + Z2
Y17 = u12 + f + Z0 + u36 + Z1 + u32
Y21 = u28 + f + Z0 + u36 + Z1
Y25 = u32 + f + Z0 + u36
Y29 = u36 + f + Z0
Y33 = u20 + f

∀ i ∈ 1,9:
Y4i-3 = uDi + T10-i(f,s2,uP1,..., uP27)
Y4i-2 = u4i-3
Y4i-1 = u4i-2
Y4i   = u4i-1

wobei

Z0 = Z(s2 , u7 , u4 , u33, u30, u18)
Z1 = Z(u5 , u35, u9 , u16, u23, u26)
Z2 = Z(u12, u21, u1 , u13, u25, u20)
Z3 = Z(u24, u15, u22, u29, u10, u28)


Prüffolgen:
Sämtliche Prüffolgen wurden mit folgenden Schlüsseln erzeugt:
(si)120= (
1i=1
0101, 0010, 1001, 0100, 1101, 0101,
1010, 0010, 0111, 0100, 1010, 1100,
1111, 0110, 0111, 1111, 0000, 1111,
0110, 0001, 0001, 0001, 1110, 1101,
0111, 1000, 1110, 0010, 0010, 1100)
(si)120= (
2i=1
1101, 0011, 0111, 1001, 1101, 1001,
0000, 0101, 0111, 0000, 1101, 0010,
1011, 0001, 0001, 1010, 1101, 1011,
1110, 0111, 0100, 1000, 1110, 0101,
1010, 0110, 0110, 1111, 0011, 0001)
(fi)0= (0001, 0000, 0101, 1111, 1111, 0101, 0011, 1010, 0110, 0111, 0100, 0000, 0001, 1111, 1111, 1)
i=-60

// SYF ist berechnet aus f.
SYF = (fi)0(0111, 0000, 1001, 0100, 1000, 0010, 1100, 0101, 1000, 1001, 0100, 1000, 1001, 1110, 1101, 1111,)
i=124   0001, 0000, 0101, 1111, 1111, 0101, 0011, 1010, 0110, 0111, 0100, 0000, 0001, 1111, 1111, 1
U0 entspricht dem in der T-310 Definition vorgegebenen Wert.
  = (0110, 1001, 1100, 0111, 1100, 1000, 0101, 1010, 0011)

a) Prüffolgen im Taktabstand 1

Es sind die jeweils ersten 28 Glieder der Folgen
(ui) , (ui) , ...,(ui) , (Zi) , (Zi) ,
1i ∈ N5i ∈ N33i ∈ N0i ∈ N1i ∈ N
(Zi) , (Zi) , (ui) , (si) , (si) ,
2i ∈ N3i ∈ N2i ∈ N1i ∈ N2i ∈ N
(Ti) , (Ti) , ...,(Ti)
1i ∈ N2i ∈ N9i ∈ N
dargestellt.
TaktU(4 * I - 3)ZU(α)S1S2T
_ Fehler in der Kopie, Wert berechnet
01:1001100001111001010111011
02:1001100111110111101011110
03:0110111100100100111000000
04:0100001001011011100011011
05:0001110001100000100111110
06:0010100110111000001010010
07:0111101001110011100100111
08:0010011101111001011000100
09:1010000010010010000001110
10:1111110101000101101101111
11:0110111100111101111000100
12:0001010101100011011010001
13:1001011100011001001111101
14:1110111010110110000101000
15:0000010111100100011011000
16:0010100110110001111011110
17:1111001000110011000100000
18:1001001101001111101110100
19:0110010111010100101101110
20:1011001011011011010011100
21:1111000011110101100111001
22:1110110110110110111010000
23:0100111001111100010101010
24:1001111100100011001001110
25:1011010010101110110111010
26:1101000101110100101010111
27:0100100001101110100111011
28:0011001010101000000100010
b) Prüffolgen im Taktabstand 127
Es sind die jeweils ersten 28 Glieder der Folgen
(u127i) , (u127i) , ...,(u127i) , (Z127i) , (Z127i) ,
1i ∈ N5i ∈ N33i ∈ N0i ∈ N1i ∈ N
(Z127i) , (Z127i) , (u127i) , (s127i) , (s127i) ,
2i ∈ N3i ∈ N2i ∈ N1i ∈ N2i ∈ N
(T127i) , (T127i) , ...,(T127i)
1i ∈ N2i ∈ N9i ∈ N
dargestellt.
TaktU(4 * I - 3)ZU(α)S1S2T
_ Fehler in der Kopie, Wert berechnet
0127:1111100010100011000110000
0254:0100000011110110010110001
0381:1011110101110001101011111
0508:1010111110111100001001011
0635:1111010011101111010110100
0762:0101011100011101001111010
0889:0101000000000111110001001
1016:1011000100111001111011011
1143:0011110101010011101100001
1270:0101000111101110101011011
1397:0110011010110000000101000
1524:0000000111000110011100001
1651:0001111001010011100011001
1778:0000010101110010101010001
1905:1100010111100110011011000
2032:1110110100010001001100111
2159:0100101101100100011000110
2286:0011000000100000110111000
2413:0010000010001001110001100
2540:1110000010001111110001100
2667:0111001010110010000101001
2794:1111110010011011110000010
2921:1111110110111011001011010
3048:0011100010101100110111100
3175:1110010101001110101100100
3302:1100001101111010101001100
3429:0101101001111011100100101
3556:0101001110100000001000110
c) Chiffrierung eines Prüftextes
Prüftext:
⟨Bu⟩⟨CR⟩⟨LF⟩ABC ... XYZ⟨Zi⟩1234567890⟨CR⟩⟨LF⟩⟨LF⟩

⟨ CR ⟩  - Wagenrücklauf
⟨ LF ⟩  - Zeilenvorschub
⟨ Bu ⟩  - Buchstabenumschaltung, Register 1
⟨ Zi ⟩  - Ziffern-/Zeichenumschaltung, Register 2
⟨ Ky ⟩  - Kyrillischumschaltung, Register 3
⟨ zwr ⟩ - Leerzeichen

Folgende Werte werden pro Zeichen ausgegeben:

GT - Grundtext
CT - Chiffiertext
A1 - entspricht (a1-13i, a2+13i, ..., a5+13i)
A2 - entspricht (a6+13i)
A3 - entspricht (a7+13i, a8+13i, ..., a11+13i)
A4 - entspricht (a12+13i, a13+13i)
ZT - GT ⊕ A3 (bitweise Addition modulo 2)

Wobei: i = 0, ..., 43

Alle ausgedruckten Zahlen stellen Dezimalzahlen dar.
Der Grundtext wurde mittels ITA 2-Code umgesetzt.
(Die Kodierung erfolgt entgegengesetzt dem ITA-2)
(Bsp: ITA-2 "E" = 1, (8-bit) 0x10 = dezimal = 16)
(Die Gelb hinterlegten Spalten ist die MBF)
8bit Format ITA-2/CITT-2 Format
BuWRZVZVABCDEFBuWRZVZVABCDEF
GT:31020808241914181622GT:31080202032514090113
A1:11100400230331190819A1:26100400292431250225
A2:01000101010000010101A2:01000101010000010101
A3:18171507311308220801A3:09173028312202130216
A4:02020101030302020101A4:01010202030301010202
ZT:13190715073006042423ZT:13252715273006042423
CT:31290115130606160206CT:31231630221212010812
BuQTVPNNEWRNBuQTVPNNEWRN
  
GHIJKLMNOPGHIJKLMNOP
GT:11051226300907060313GT:26200611151827122422
A1:22221929060323181722A1:13132523122429091713
A2:01010001000000010100A2:01010001000000010100
A3:07110816103006030820A3:28260201101512240205
A4:03020103020101000203A4:03010203010202000103
ZT:12140410202301051125ZT:12140410202301051125
CT:04171622091025101909CT:04170113181019102518
zwrZEFLRWRBLzwrZEFLRWRBL
  
QRSTUVWXYZQRSTUVWXYZ
GT:29102001281525232117GT:23100516073019292117
A1:28111303281812101112A1:07262224070906102606
A2:00000100010000000100A2:00000100010000000100
A3:08242527240720092922A3:02031927032805182313
A4:02000001020300010303A4:01000002010300010303
ZT:21181326040813300807ZT:21181326040813300827
CT:20201016181328202311CT:05051001092207052926
SSREDPUSXGSSREDPUSXG
  
Zi123456789Zi123456789
GT:27292516100121281203GT:27231901101621070624
A1:31272714142803102620A1:31272714140724101105
A2:00010000010001000101A2:00010000010001000101
A3:20042009080023220600A3:05040518020029131200
A4:02020201000200000203A4:01010102000100000103
ZT:15251325020102101003ZT:15251325020102101003
CT:15172006070411191204CT:30170512270426250604
VZSNMzwrGBIzwrVZSNMzwrGBIzwr
  
0WRZVZV      0WRZVZV      
GT:13020808GT:22080202
A1:15162213A1:30011322
A2:01000000A2:01000000
A3:30291724A3:15231703
A4:03030000A4:03030000
ZT:19312516ZT:19312516
CT:25160911CT:19011826
WELGWELG
Referat 21                              Berlin, 19. Juli 1990
Das Dokument ist in 2 Exemplaren gefertigt.

Verteiler: 1. Ex. ZSI
           2. Ex. ZCO/Referat 21

Quellen: Kryptologische Analyse T-310, GVS 402/80
         Kryptologische Dokumentation zum LSZ 31, GVS 178/85

Beispielcode in C, Optimierungen wurden für die Verständlichkeit nicht realisiert.
Auf Windows, Linux und Microcontroller, unter allen Programmiersprachen, anwendbar.
T-310 BTZ GLCD
Abb.: GLCD Darstellung des BT/BTZ.
// Konstanten: U33(2), U5(6), U9(8), U21(14), U25(17), U29(23)
byte b_LZS[37] { 7, 4, 33, 30, 18, 36, 5, 35, 9, 16, 23, 26, 32, 12, 21, 1, 13, 25,
                20, 8, 24, 15, 22, 29, 10, 28, 6, 0, 16, 4, 24, 12, 28, 32, 36, 20, 2 };
                // Zugelassen; LZS-31, Langzeitschlüssel

unsigned long ul_syncronfolge = 0ul; // Syncronfolge
boolean s1_bit[120];
boolean s2_bit[120];
boolean bo_U_Vektor[37];
byte b_zeiger = 0;

// der U-Vektor ist die Startbedingung der 4bitigen Schieberegister, U[0] wird nicht genutzt!
boolean init_U_Vektor[37] {
 false, false, true, true, false, true, false, false,
 true, true, true, false, false, false, true, true,
 true, true, true, false, false, true, false, false,
 false, false, true, false, true, true, false, true,
 false, false, false, true, true
};

unsigned long Zufall()
{
  unsigned long ul_kg = 0; // variable Kenngruppe
  while (ul_kg == 0ul)
  {
    ul_kg = random(); // die ersten 32 bit
    ul_kg <<= 32;
    unsigned long ul_kg2 = random();
    ul_kg |= ul_kg2;         // die letzten 32 bit
    ul_kg &= 0x1fffffffffffffff; // Maskieren auf 61 Bit
  }
  return ul_kg;
}

void main()
{
  if (Senden == true) Chiffrieren(Text);
  else if (Empfangen == true) Dechiffrieren(Text);
}

void UVektorInit()
{
  byte x = 0;
  do
  {
    bo_U_Vektor[x] = init_U_Vektor[x];
    x++;
  } while (x < 37);
}

unsigned int KE()
{
  byte b_fsBit = 0;
  unsigned int ui_wurmBit = 0;
  bool bo_Y_Vektor[9]; // Ergebnis und U-Vektoren, Beachtung zeitlicher Abläufe
  bool bo_Z[4];        // Z0 ... Z3 (Z1 bis Z4)
  /* 5 bit sammeln aus 127ten runde * bit des Fs Zeichen,
    127 - 254 - 381 - 508 - 635 - 762 - 889 - 1016 - 1143 - 1270 - 1397 - 1524 - 1651,
    neues FsZeichen mit: 1778,  n + 127...*/
  do                         // Achtung 13 Runden, Bit 0, 6, 12 und 13 sind ungenutzt
  {
    for (byte b_runde = 0; b_runde < 127; ++b_runde)
    {
      boolean bo_tempS1 = s1_bit[b_zeiger]; // S1 in T92 - Y1
      boolean bo_tempS2 = s2_bit[b_zeiger]; // S2 in Z0, T61 - Y13
      //Beachtung des zeitlichen Ablaufes der elektronischen Schaltung!
      // Konstanten: U33(2), U5(6), U9(8), U21(14), U25(17), U29(23)
      // T-Funktion mit LZS xx - entsprechend Auswahl; b_LZS[] die P'' Werte

      bo_Z[0] = Z(bo_tempS2, bo_U_Vektor[b_LZS[0]], bo_U_Vektor[b_LZS[1]], bo_U_Vektor[33], bo_U_Vektor[b_LZS[3]], bo_U_Vektor[b_LZS[4]]);
      bo_Z[1] = Z(bo_U_Vektor[5], bo_U_Vektor[b_LZS[7]], bo_U_Vektor[9], bo_U_Vektor[b_LZS[9]], bo_U_Vektor[b_LZS[10]], bo_U_Vektor[b_LZS[11]]);
      bo_Z[2] = Z(bo_U_Vektor[b_LZS[13]], bo_U_Vektor[21], bo_U_Vektor[b_LZS[15]], bo_U_Vektor[b_LZS[16]], bo_U_Vektor[25], bo_U_Vektor[b_LZS[18]]);
      bo_Z[3] = Z(bo_U_Vektor[b_LZS[20]], bo_U_Vektor[b_LZS[21]], bo_U_Vektor[b_LZS[22]], bo_U_Vektor[29], bo_U_Vektor[b_LZS[24]], bo_U_Vektor[b_LZS[25]]);

      ul_syncronfolge = Rot_Ffolge(ul_syncronfolge);     // rotiere F-Folge die Syncronfolge einmal
      bool bo_T = (ul_syncronfolge & 0x1000000000000000ul) != 0;

      // Y = Werte entsprechend LZS-31                            D   xor f xor Z xor P''

      bo_Y_Vektor[0] = bo_U_Vektor[b_LZS[35]] ^ bo_T;    // Y33 = U20 xor f
      bo_T ^= bo_Z[0];
      bo_Y_Vektor[1] = bo_U_Vektor[b_LZS[34]] ^ bo_T;    // Y29 = U36 xor f xor Z0
      bo_T ^= bo_U_Vektor[b_LZS[5]];                     //       U36 entsprechend P''
      bo_Y_Vektor[2] = bo_U_Vektor[b_LZS[33]] ^ bo_T;    // Y25 = U32 xor f xor Z0 xor U36
      bo_T ^= bo_Z[1];
      bo_Y_Vektor[3] = bo_U_Vektor[b_LZS[32]] ^ bo_T;    // Y21 = U28 xor f xor Z0 xor U36 xor Z1
      bo_T ^= bo_U_Vektor[b_LZS[12]];                    //       U12 entsprechend P''
      bo_Y_Vektor[4] = bo_U_Vektor[b_LZS[31]] ^ bo_T;    // Y17 = U12 xor f xor Z0 xor U36 xor Z1 xor U32
      bo_T ^= bo_tempS2 ^ bo_Z[2];
      bo_Y_Vektor[5] = bo_U_Vektor[b_LZS[30]] ^ bo_T;    // Y13 = U24 xor f xor Z0 xor U36 xor Z1 xor U32 xor S2 xor Z2
      bo_T ^= bo_U_Vektor[b_LZS[19]];                    //       U8 entsprechend P''
      bo_Y_Vektor[6] = bo_U_Vektor[b_LZS[29]] ^ bo_T;    // Y9  = U4  xor f xor Z0 xor U36 xor Z1 xor U32 xor S2 xor Z2 xor U8
      bo_T ^= bo_Z[3];
      bo_Y_Vektor[7] = bo_U_Vektor[b_LZS[28]] ^ bo_T;    // Y5  = U16 xor f xor Z0 xor U36 xor Z1 xor U32 xor S2 xor Z2 xor U8 xor Z3
      bo_T ^= bo_U_Vektor[b_LZS[26]];                    //       U6 entsprechend P''
      bo_Y_Vektor[8] = bo_tempS1 ^ bo_T;                 // Y1  = S1  xor f xor Z0 xor U36 xor Z1 xor U32 xor S2 xor Z2 xor U8 xor Z3 xor U6

      bo_U_Vektor[36] = bo_U_Vektor[35]; // U-Vektoren schieben
      bo_U_Vektor[35] = bo_U_Vektor[34];
      bo_U_Vektor[34] = bo_U_Vektor[33];
      bo_U_Vektor[33] = bo_Y_Vektor[0];  // Y33
      bo_U_Vektor[32] = bo_U_Vektor[31];
      bo_U_Vektor[31] = bo_U_Vektor[30];
      bo_U_Vektor[30] = bo_U_Vektor[29];
      bo_U_Vektor[29] = bo_Y_Vektor[1];  // Y29;
      bo_U_Vektor[28] = bo_U_Vektor[27];
      bo_U_Vektor[27] = bo_U_Vektor[26];
      bo_U_Vektor[26] = bo_U_Vektor[25];
      bo_U_Vektor[25] = bo_Y_Vektor[2];  // Y25;
      bo_U_Vektor[24] = bo_U_Vektor[23];
      bo_U_Vektor[23] = bo_U_Vektor[22];
      bo_U_Vektor[22] = bo_U_Vektor[21];
      bo_U_Vektor[21] = bo_Y_Vektor[3];  // Y21;
      bo_U_Vektor[20] = bo_U_Vektor[19];
      bo_U_Vektor[19] = bo_U_Vektor[18];
      bo_U_Vektor[18] = bo_U_Vektor[17];
      bo_U_Vektor[17] = bo_Y_Vektor[4];  // Y17;
      bo_U_Vektor[16] = bo_U_Vektor[15];
      bo_U_Vektor[15] = bo_U_Vektor[14];
      bo_U_Vektor[14] = bo_U_Vektor[13];
      bo_U_Vektor[13] = bo_Y_Vektor[5];  // Y13;
      bo_U_Vektor[12] = bo_U_Vektor[11];
      bo_U_Vektor[11] = bo_U_Vektor[10];
      bo_U_Vektor[10] = bo_U_Vektor[9];
      bo_U_Vektor[9] = bo_Y_Vektor[6];   // Y9;
      bo_U_Vektor[8] = bo_U_Vektor[7];
      bo_U_Vektor[7] = bo_U_Vektor[6];
      bo_U_Vektor[6] = bo_U_Vektor[5];
      bo_U_Vektor[5] = bo_Y_Vektor[7];   // Y5;
      bo_U_Vektor[4] = bo_U_Vektor[3];
      bo_U_Vektor[3] = bo_U_Vektor[2];
      bo_U_Vektor[2] = bo_U_Vektor[1];
      bo_U_Vektor[1] = bo_Y_Vektor[8];   // Y1;

      ++b_zeiger;                             // Zeiger auf nächstes Bit
      if (b_zeiger > 119) b_zeiger = 0;       // Zeiger entspricht das rotieren des Schlüssels S1, S2
    }                                         // for, 127 Runden!
    if (bo_U_Vektor[b_LZS[36]] == true)       // Reihenfolge in der PC-Darstellung reverse!
    {
      if (b_fsBit < 5)
      {
        ui_wurmBit |= (unsigned int)(0x1 << b_fsBit);
      }
      if ((b_fsBit > 5) & (b_fsBit < 11))
      {
        ui_wurmBit |= (unsigned int)(0x1 << b_fsBit);
      }

    }
    ++b_fsBit;                                 // nächstes bit
  } while (b_fsBit < 13);                      // while 13 Runden
  ui_wurmBit &= 0x7df;                         // Maskieren bit 0 bis 4, bit 6 bis 10
  return ui_wurmBit;                           // Rückgabe 11 bit Wurm
}

byte Chiffrieren(byte b_klartext)
{
  unsigned int ui_key = KE();
  // Schritt 1 ... 5, Schieberegister aufbauen
  byte b_SRV3 = 0x1f;                             // Runden bis 0x1f in SRV2
  byte b_SRV2 = (byte)(ui_key & 0x1f);            // bit 0 ... bit 4 == 1-5 des Schlüssels, Schritt 1 ... 5, Schritt 6, Symetriewert bilden, rekursion
  while ((b_SRV2 < 0x1f) & (b_SRV2 > 0))
  { // wenn 11111, 0x1f ODER 0 abbrechen
    b_SRV2 = Rekursion(b_SRV2);
    b_SRV3 = Rekursion(b_SRV3);
  }
  // Schritt 6  *****************************        Bit 6 bleibt ungenutzt!, Schritt 7 ... 11
  b_SRV2 = b_SRV3;                                // b_SRV3 nach b_SRV2 kopieren
  b_SRV3 = (byte)(b_klartext ^ ((ui_key & 0x07c0) >> 6));   // Additionsreihe bit 6 bis 10 (7 ... 11) XOR Ktxt (5bit), Schritt 7 ... 11
  while ((b_SRV2 < 0x1f) & (b_SRV2 > 0))          // bit 0 bis 4 (1-5)
  { // wenn 11111 ( 0x1f oder 31 ) ODER 0 abbrechen
    b_SRV2 = Rekursion(b_SRV2);
    b_SRV3 = Rekursion(b_SRV3);
  }
  // Schritt 13, neues Zeichen holen und neue Schlüssel und beginn bei Schritt 1
  return b_SRV3;   // Ausgabe Chiffriertext
}

byte Dechiffrieren(byte b_crypt)
{
  unsigned int ui_key = KE();
  byte b_SRV3 = b_crypt;
  byte b_SRV2 = (byte)(ui_key & 0x1f);        // bit 0 bis 4 (1-5)
  while ((b_SRV2 < 0x1f) & (b_SRV2 > 0))
  { // Rekursion der Additionsreihe in SRV2 und des GTX in SRV3
    b_SRV2 = Rekursion(b_SRV2);
    b_SRV3 = Rekursion(b_SRV3);             // Z gebildet
  }
  b_SRV3 ^= (byte)((ui_key & 0x07c0) >> 6);   // XOR Additionsreihe bit 6 bis 11 (7 ... 11) mit dem Zwischentext Z
  return b_SRV3;
}

bool Z(bool b_1,bool b_2,bool b_3,bool b_4,bool b_5,bool b_6)
{
  bool bo_temp =true ^ b_1 ^ b_5 ^ b_6 ^ (b_1 && b_4);
  bo_temp ^= (b_2 && b_3) ^ (b_2 && b_5) ^ (b_4 && b_5) ^ (b_5 && b_6);
  bo_temp ^= (b_1 && b_3 && b_4) ^ (b_1 && b_3 && b_6) ^ (b_1 && b_4 && b_5);
  bo_temp ^= (b_2 && b_3 && b_6) ^ (b_2 && b_4 && b_6) ^ (b_3 && b_5 && b_6);
  bo_temp ^= (b_1 && b_2 && b_3 && b_4) ^ (b_1 && b_2 && b_3 && b_5);
  bo_temp ^= (b_1 && b_2 && b_5 && b_6) ^ (b_2 && b_3 && b_4 && b_6);
  bo_temp ^= (b_1 && b_2 && b_3 && b_4 && b_5) ^ (b_1 && b_3 && b_4 && b_5 && b_6);
  return (bo_temp);
}


static byte Rekursion(byte b_Register)
{
  const byte b_Bit0 = 0x01;
  const byte b_Bit3 = 0x04;
  const byte b_5Bitmaske = 0x1f; // Bitmaske aller werte innerhalb von 0 ... 31
  byte b_ret = b_Register;       // übergabe der Eingabe an das Ausgabebyte
  bool bo_xor = ((b_Bit0 & b_ret) != 0) ^ ((b_Bit3 & b_ret) != 0);
  b_ret >>= 1;                   // bo_XOR bildet rekusrionsbit aus Bit 5 und Bit 3
  b_ret |= (byte)(bo_xor == true ? 0x10 : 0);
  b_ret &= b_5Bitmaske;
  return b_ret;
}

unsigned long Syncronfolge(unsigned long ul_Para, byte b_Runden)
{
  for (byte b_i = 0; b_i < b_Runden; ++b_i)
  { // Umformung durch Bit 0 xor 1 xor 2 xor 5
    ul_Para = Rot_Ffolge(ul_Para);
  }
  return ul_Para;
}

/* rotiere f-Folge */
unsigned long Rot_Ffolge(unsigned long ul_Paramter)
{
  bool bo_m2; // ergebnis des XOR bit 0,1,2,5
  bo_m2 = ((ul_Paramter & 0x1ul) != 0ul) ^ ((ul_Paramter & 0x2ul) != 0ul) ^ ((ul_Paramter & 0x4ul) != 0ul) ^ ((ul_Paramter & 0x20ul) != 0ul); // Umformung durch Bit 0 xor 1 xor 2 xor 5
  ul_Paramter >>= 1;     // Shift 1, von 60 nach 0
  if (bo_m2 == true)
  {
    ul_Paramter |= 0x1000000000000000ul;   // bit 61
  }
  return ul_Paramter;
}