#include <iostream>

using namespace std;

int main() {
    char text[256] = "";
    char dec_text[256] = "";
    char pw[12]   = "";
    cout << "Text:" << endl;
    cin >> text;
    cout << "Password:" << endl;
    cin >> pw;
    // Per Blowfisch soll das nun verschlüsselt werden
    dec_text = blowfisch(text, pw);  // :) ?
    cout << "Verschluesselter Text:" << dec_text << endl; 
    return 0;
}

So stelle ich es mir vor.

Es gibt da auch schon C codestücke zu:
(SOrry, ist einbisschen viel, aber ich blicke da garnicht durch - außerdem haben dann auch interessierte eine grundlage)
blow.cpp:

#ifdef little_endian   /* Eg: Intel */
   #include <dos.h>
   #include <graphics.h>
   #include <io.h>
#endif

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#ifdef little_endian   /* Eg: Intel */
   #include <alloc.h>
#endif

#include <ctype.h>

#ifdef little_endian   /* Eg: Intel */
   #include <dir.h>
   #include <bios.h>
#endif

#ifdef big_endian
   #include <Types.h>
#endif

#include "Blowfish.h"

#define N               16
#define noErr            0
#define DATAERROR         -1
#define KEYBYTES         8
#define subkeyfilename   "Blowfish.dat"

unsigned long P[N + 2];
unsigned long S[4][256];
FILE*         SubkeyFile;

short opensubkeyfile(void) /* read only */
{
   short error;

   error = noErr;

   if((SubkeyFile = fopen(subkeyfilename,"rb")) == NULL) {
      error = DATAERROR;
   }

   return error;
}

unsigned long F(unsigned long x)
{
   unsigned short a;
   unsigned short b;
   unsigned short c;
   unsigned short d;
   unsigned long  y;

   d = x & 0x00FF;
   x >>= 8;
   c = x & 0x00FF;
   x >>= 8;
   b = x & 0x00FF;
   x >>= 8;
   a = x & 0x00FF;
   //y = ((S[0][a] + S[1][b]) ^ S[2][c]) + S[3][d];
   y = S[0][a] + S[1][b];
   y = y ^ S[2][c];
   y = y + S[3][d];

   return y;
}

void Blowfish_encipher(unsigned long *xl, unsigned long *xr)
{
   unsigned long  Xl;
   unsigned long  Xr;
   unsigned long  temp;
   short          i;

   Xl = *xl;
   Xr = *xr;

   for (i = 0; i < N; ++i) {
      Xl = Xl ^ P[i];
      Xr = F(Xl) ^ Xr;

      temp = Xl;
      Xl = Xr;
      Xr = temp;
   }

   temp = Xl;
   Xl = Xr;
   Xr = temp;

   Xr = Xr ^ P[N];
   Xl = Xl ^ P[N + 1];

   *xl = Xl;
   *xr = Xr;
}

void Blowfish_decipher(unsigned long *xl, unsigned long *xr)
{
   unsigned long  Xl;
   unsigned long  Xr;
   unsigned long  temp;
   short          i;

   Xl = *xl;
   Xr = *xr;

   for (i = N + 1; i > 1; --i) {
      Xl = Xl ^ P[i];
      Xr = F(Xl) ^ Xr;

      /* Exchange Xl and Xr */
      temp = Xl;
      Xl = Xr;
      Xr = temp;
   }

   /* Exchange Xl and Xr */
   temp = Xl;
   Xl = Xr;
   Xr = temp;

   Xr = Xr ^ P[1];
   Xl = Xl ^ P[0];

   *xl = Xl;
   *xr = Xr;
}

short InitializeBlowfish(char key[], short keybytes)
{
   short          i;
   short          j;
   short          k;
   short          error;
   short          numread;
   unsigned long  data;
   unsigned long  datal;
   unsigned long  datar;

   /* First, open the file containing the array initialization data */
   error = opensubkeyfile();
   if (error == noErr) {
      for (i = 0; i < N + 2; ++i) {
	 numread = fread(&data, 4, 1, SubkeyFile);
   #ifdef little_endian      /* Eg: Intel   We want to process things in byte   */
			   /*   order, not as rearranged in a longword          */
	 data = ((data & 0xFF000000) >> 24) |
		((data & 0x00FF0000) >>  8) |
		((data & 0x0000FF00) <<  8) |
		((data & 0x000000FF) << 24);
   #endif

	 if (numread != 1) {
	    return DATAERROR;
	 } else {
	    P[i] = data;
	 }
      }

      for (i = 0; i < 4; ++i) {
	 for (j = 0; j < 256; ++j) {
	     numread = fread(&data, 4, 1, SubkeyFile);

   #ifdef little_endian      /* Eg: Intel   We want to process things in byte   */
			   /*   order, not as rearranged in a longword          */
	    data = ((data & 0xFF000000) >> 24) |
		   ((data & 0x00FF0000) >>  8) |
		   ((data & 0x0000FF00) <<  8) |
		   ((data & 0x000000FF) << 24);
   #endif

	     if (numread != 1) {
	       return DATAERROR;
	    } else {
	       S[i][j] = data;
	    }
	 }
      }

      fclose(SubkeyFile);

      j = 0;
      for (i = 0; i < N + 2; ++i) {
	 data = 0x00000000;
	 for (k = 0; k < 4; ++k) {
	    data = (data << 8) | key[j];
	    j = j + 1;
	    if (j >= keybytes) {
	       j = 0;
	    }
	 }
	 P[i] = P[i] ^ data;
      }

	datal = 0x00000000;
      datar = 0x00000000;

      for (i = 0; i < N + 2; i += 2) {
	 Blowfish_encipher(&datal, &datar);

	 P[i] = datal;
	 P[i + 1] = datar;
      }

      for (i = 0; i < 4; ++i) {
	 for (j = 0; j < 256; j += 2) {

	    Blowfish_encipher(&datal, &datar);

	    S[i][j] = datal;
	    S[i][j + 1] = datar;
	 }
      }
   } else {
      printf("Unable to open subkey initialization file : %d\n", error);
   }

   return error;
}

Blowfish.h

#define MAXKEYBYTES 56          /* 448 bits */
// #define little_endian 1              /* Eg: Intel */
#define big_endian 1            /* Eg: Motorola */

short opensubkeyfile(void);
unsigned long F(unsigned long x);
void Blowfish_encipher(unsigned long *xl, unsigned long *xr);
void Blowfish_decipher(unsigned long *xl, unsigned long *xr);

Wie kann ich nun diesen cryptischen krassen blowfisch code mit meinem code verbinden?

Wie kann ich nun diesen cryptischen krassen blowfisch code mit meinem code verbinden?

Indem du dich mit dem Thema beschäftigst und es verstehen lernst, dann kannst du dir auch leicht eine eigene Implementierung schreiben.
Oder du machst es auf die einfache Art, schaust in die Doku, oder falls die nicht vorhanden ist, schaust du dir die verfügbare Schnittstelle an und dann sollte das auch kein Problem mehr sein.

ist echt ein wenig mehr C++ ^^

bb

...Wie kann ich nun diesen cryptischen krassen blowfisch code mit meinem code verbinden?

Also ehrlich gesagt: Ich weiß gar nicht, wo Dein Problem liegt ?
Du hast Dein aufrufendes Programm (mit main()) und das "Angelieferte" (mit Blowfish_encipher() und -decipher()).
Einziger Unterschied ist halt noch, dass die auzurufende Funktion nicht "blowfish()" heisst, sondern eben "Blowfish_encipher()" ...

Vielleicht fehlen Dir auch noch 2 Informationen:
1.) In Deiner Entwicklungsumgebung verbindest Du verschiedene Module über "includieren" und "linken"
2.) Zum Ver-/Entschlüsseln gehört immer auch ein "Schlüssel" (wird hier anscheinend separat der Funktion "Initialize_Blowfish()" übergeben) ... das hat aber nichts mit C oder C++ zu tun, sondern darüber musst Du Dir inhaltlich Gedanken machen: Wo kommt der her bzw. wo legst Du den ab ?

BTW: Mir scheint das eine ziemlich garstige Blowfish-Implementation zu sein (so mit Schlüsselteile in Files ablegen) und auch programmiertechnisch ist das ziemlich übel (warum kommen eigentlich die Leute immer wieder auf die Idee, Variablen a,b,c,d, ... zu nennen ?).
ich weiß jedenfalls nicht, warum Du an diesem Code so hängst, wo es doch deutlich bessere (hier schon genannte) Alternativen gibt.

Gruß,

Simon2.

Ich wollte nur ein zwei dateien haben wo blowfish impliziert ist und keine ganze api.

1. Das hast Du ja.
2. Es heisst implementiert, nicht impliziert.

Simon

...Vor alem verplichtet crypt++ wie ich lass zur nutzung der GPL.

Das sehe ich ein.
Trotzdem vermute ich, dass Du bessere (auch "freie") Implementierungen von blowfish bekommst... auch, wenn ich Dir keine konkrete nennen kann.

Gruß,

Simon2.

Trotzdem vermute ich, dass Du bessere (auch "freie") Implementierungen von blowfish bekommst... auch, wenn ich Dir keine konkrete nennen kann.

wahrscheinlich das original: http://www.schneier.com/code/bfsh-sch.zip