/*s*/ /* code::shift_code */
/*s*/ /* Komment */
/* ----------------------------------- schift --------------------------
Kommentar:

          Diese Routine ist für das Kodieren gedacht.
          Als erstes wird mit dem Zeichenvorrates des Schlüssels
          gearbeitet. Ist Dieser aufgebraucht wird der Kodierte Text heranngezogen.
          Der Offset zwischen den Zeichen betrüge dann der länge des
          Schlüssels.

          Ich bein ein zu Kodierender Text
          Ich bin ein Schlüssel
          xxx ich bin Kodiert x
                               ^
          ab dem r würde die Kodierung für den rest des Textes so
aussehen:
          render Text
          xxx ich bin

          Sobal der Schlüssel alle ist, wird einfach der Anfang des
Kodierten textes
          verwendet um weiterzu Kodieren.

          Der Algorhytmus basiert nur auf das verschieben von Bit's, da
einige
          möchtegern Programmierer, die alles Knacken und alles wissen
wollen, meinen
          die kleinste Informationseinheit sei ein Byte und von Bits nix
wissen :-)
          Is zwar gemein - aber sie haben gelernt das es doch etwas
schwerer ist
          als ein PRINT chr$(asc(a) - 20) ;>

          Zum verschieben:

          Das Keybyte wird in 2 Teile zerlegt: In 4 obere und 4 Untere
Bits - je in eine
          Variable. Die Oberen Bits werden in die Unteren verschoben.

          Key = 00111100 -> 00110000 00001100
                         -> 00000011 00001100

          Die 2 Variablen werden noch mit einem UND mit der Bitmaske
00000111 belegt, um Werte
          über 7 zu unterbinden, danach mit einem ODER 00000001 belegt
um auf jedenfall einen schiebeeffekt zu erhalten.

          Nun werden die 2 Variablen verglichen. Dies führt eine
Entscheidung bei, ob nach
          links oder rechts geschoben werden soll. Die anzahl der Bits
um die geschoben werden soll
          steht in der oben ermittelten Hilfsvariable, die einen Wert
zwischen 1 und 7 enthält.

          Ein Schwachpunkt weist die Routine auf: Wird als Key ""
übergeben und enthält
          der Text einige gleiche Zeichen wie XXXXXXXXXXXXXXXXXXXX
werden diese auch
          gleich kodiert. z.B. wäre das ergebnis cccccccccccccccccc

          Hat man keinen Key angegeben, kann man den Text über
Häufigkeitsauszählungen
          Rekonstruieren.

*/
/*e*/

char* code::shift_code(char* txt,long txtlength,char* key,long keylength)
{

 long int i = 0;
 long int j = 0;
 long int k = 0;
 char help1,help2;

/*s*/ /* Code with Key */
// Kodieren kodieren ;>>>  (Bis schlüssel zu ende)
          for(i=0,j=0 ;j<=keylength & i<=txtlength;i++,j++)
             {
                  help1 = *(key+j);  // Hilfsvariable 1 bilden
                  help2 = *(key+j);  // ""            2 ""

                  help1>>=4; // 1 Verschieben
                  help1&=7;  /* %00001111*/ // (Obersten 4 Bits)
                  help2&=7;  // Verknüpfen um Untersten 4 Bits zu erhalten.
                  help1|=1;  // minimum 1 setzen
                  help2|=1;  // ""

                // Mittels help1 und help2 wird entschieden ob rechts oder links
                // rotiert werden soll - wobei die richtung aus dem Key errechnet wird.
                  if(help1>help2)
                    {
                            *(txt+i) = (unsigned char) rorb((int)help1,*(txt+i));
                    }
                  else
                     {
                            *(txt+i) = (unsigned char) rolb((int)help2,*(txt+i));
                     }

             }
/*e*/

/*s*/ /* Code without Key */
// Testen ob Text noch vorhanden
          if(i<txtlength)
            {
             // Laufen bis Text am Ende ist - k für Offset verwenden
             for(k=0;i<=txtlength ;k++,i++ )
                {
                  help1 = *(txt+k); // Diesmal aus Text hilfsvariable ermitteln
                  help2 = *(txt+k); //

                  help1>>=4; // Drehrichtung vorbereiten
                  help1&=7; /* %00001111*/
                  help2&=7;
                  help1|=1;
                  help2|=1;

                  // Kodieren
                  if(help1>help2)
                    {
                            *(txt+i) = (unsigned char) rorb((int)
                            help1,*(txt+i));
                    }
                  else
                     {
                            *(txt+i) = (unsigned char) rolb((int)
                            help2,*(txt+i));
                     }

                }

            }
/*e*/

   return((char*)txt);

}

/*e*/

/*s*/ /* code::shift2_decode */
/*s*/ /* Komment */
/* ----------------------------------- schift --------------------------
Kommentar:

          Diese Routine dekodiert das mit schift kodierte Objekt.
          Als erstes wird in der Routine der Offset berechnet wenn der
Key
          kürzer ist als der zu Kodierende Text. Bis zu dem Offset wird
das
          Object rückwärts dekodiert, da die vorderen Bytes, auch wenn
sie nicht
          mit dem Schlüssel Kodiert wurden, benötigt werden. Das Object
rückwärts
          decodiert wird nun vom Anfang mit dem Schlüssel kodiert.

                                       a           b
          xxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy

xxx -> Kodert mit Key
yyy -> folgecodierung
a   -> Offset (textlänge - schlüssellänge-1)
z   -> Key
b   -> End bzw. Startposition

Rückwärts dekodieren

                                    a           b
          xxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy

                               a           b
          xxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy

                      a           b
          xxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy

Der rest muß mit dem Key rekonstruiert werden.

                     z           b
          xxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy

               z           b
          xxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy

          z           b
          xxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy

*/
/*e*/


char* code::shift_decode(char* txt,long txtlength,char* key,long keylength)
{

 register int i = 0;
 register int j = 0;
 register int k = 0;
 char help1,help2;

/*s*/ /* Code without Key */

// Im prinzip wie oben - nur das wie bei der XOR2_DECODE von hinten
// aus dekodiert werden muss!
           {
             for(k=txtlength-keylength-1,i=txtlength;i>=0 & k>=0 ;k--,i-- )
                {

                  help1 = *(txt+k);
                  help2 = *(txt+k);

                  help1>>=4;
                  help1&=7; /* %00001111*/
                  help2&=7;
                  help1|=1;
                  help2|=1;

                  if(help1>help2)
                    {
                            *(txt+i) = rolb((int) help1,*(txt+i));
                    }
                  else
                     {
                            *(txt+i) = rorb((int) help2,*(txt+i));
                     }

                }
             }

/*e*/

/*s*/ /* Code with Key */
          for(i=0,j=0 ;j<=keylength & i<=txtlength;i++,j++)
             {
                  help1 = *(key+j);
                  help2 = *(key+j);

                  help1>>=4;
                  help1&=7; /* %00001111*/
                  help2&=7;
                  help1|=1;
                  help2|=1;

                  if(help1>help2)
                    {
                            *(txt+i) = rolb((int) help1,*(txt+i));
                    }
                  else
                     {
                            *(txt+i) = rorb((int) help2,*(txt+i));
                     }

             }
/*e*/

   return((char*)txt);

}

/*e*/