MD5 Verschlüsselung in C

[Micha (Gast)]

Hallo,

ich möchte einen eingelesenen String in MD5 verschlüsseln, doch leider 
verstehe ich nicht ganz die Abläufe die abgearbeitet werden.

Hat jemand ein funktionierendes Beispiel das einfach in ein bestehendes 
Programm eingebunden werden kann ?

Über eine schnelle Antwort wäre ich dankbar!

Gruß Micha

[c♯-Hasser (Gast)]

MD5 ist keine Verschlüsselung, sondern ein Hash.
Also sowas wie eine Prüfsumme.
Immer noch was du brauchst?

[Jörg W. (dl8dtl) (Moderator)]

Opensource-Implementierungen davon findest du mit minimaler Suche
genügend (openssl, BSD libc, GNU libc).  Was genau fehlt dir denn?

[Micha (Gast)]

Ok, sorry für die Verwechslung... ich meine natürlich "Hash".

Ich lese einen 16Byte Hex-Code ein. Darauf soll der Hash berechnet 
werden aber ich komme mit der implementierung nicht zurecht.

Ich habe mir mal die files runtergeladen 
(http://sourceforge.net/projects/libmd5-rfc/files/) aber ich verstehe 
den Quellcode nicht ganz. Liegt wahrscheinlich auch daran.

Ich will einfach die 16Bytes aus einem Array der "md5_finish" Funktion 
übergeben und den fertig gerechneten Hash in ein weiteres 16Byte Array 
speichern.
Eigentlich ganz simpel aber wie gesagt.... ich verstehe den Code nicht 
ganz!

[Jörg W. (dl8dtl) (Moderator)]

Micha schrieb:

> Ich lese einen 16Byte Hex-Code ein. Darauf soll der Hash berechnet
> werden

Das ist nahezu widersinnig. ;-)  MD5 selbst ergibt 128 Bit, also
16 Bytes.  Du könntest also gleich deine 16 Bytes selbst als
Unterscheidungskriterium benutzen ...

> Ich habe mir mal die files runtergeladen
> (http://sourceforge.net/projects/libmd5-rfc/files/) aber ich verstehe
> den Quellcode nicht ganz.

Muss man das?

Normalerweise sollte man die Dokumentation verstehen.  Tja, sowas
ist aber für die Leute dieses Projekts offenbar ein Fremdwort.

Hier mal ein Auszug aus der FreeBSD-Manpage für md5(3):

     #include <sys/types.h>
     #include <md5.h>

     void
     MD5Init(MD5_CTX *context);

     void
     MD5Update(MD5_CTX *context, const void *data, unsigned int len);

     void
     MD5Pad(MD5_CTX *context);

     void
     MD5Final(unsigned char digest[16], MD5_CTX *context);
...
     The MD5Init(), MD5Update(), and MD5Final() functions are the core func-
     tions.  Allocate an MD5_CTX, initialize it with MD5Init(), run over the
     data with MD5Update(), and finally extract the result using MD5Final().

Vielleicht kannst du ja an Hand dieser Erklärung deinen Weg durch
die Benutzung der Funktionen deiner Bibliothek finden.

Wenn es dir nur auf die Benutzung des MD5-Algorithmusses ankommt,
würde ich an deiner Stelle nicht unbedingt versuchen, die
Implementierung selbst zu verstehen.

[Micha (Gast)]

Gibt es dazu auf die passende *.c und *.h File... habe mir grad das 
Packet von http://www.openssl.org/source/ runtergeladen aber die 
genannten Funktionen befinden sich nicht in den MD5-Files !

[Jörg W. (dl8dtl) (Moderator)]

So?

% cat /usr/src/crypto/openssl/crypto/md5/md5.h
/* crypto/md5/md5.h */
/* Copyright (C) 1995-1998 Eric Young ([e-mail])
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young ([e-mail]).
 * The implementation was written so as to conform with Netscapes SSL.
...
 */

...
int MD5_Init(MD5_CTX *c);
int MD5_Update(MD5_CTX *c, const void *data, size_t len);
int MD5_Final(unsigned char *md, MD5_CTX *c);
...

[Micha (Gast)]

Sorry wenn ich gerade auf dem Schlauch stehe aber wo sind die 
Funktionsdeklarationen für "MD5_Init", "MD5_Update", .... ?

md5.c

#include <stdio.h>
#include <stdlib.h>
#include <openssl/md5.h>

#define BUFSIZE  1024*16

void do_fp(FILE *f);
void pt(unsigned char *md);
#if !defined(_OSD_POSIX) && !defined(__DJGPP__)
int read(int, void *, unsigned int);
#endif

int main(int argc, char **argv)
  {
  int i,err=0;
  FILE *IN;

  if (argc == 1)
    {
    do_fp(stdin);
    }
  else
    {
    for (i=1; i<argc; i++)
      {
      IN=fopen(argv[i],"r");
      if (IN == NULL)
        {
        perror(argv[i]);
        err++;
        continue;
        }
      printf("MD5(%s)= ",argv[i]);
      do_fp(IN);
      fclose(IN);
      }
    }
  exit(err);
  }

void do_fp(FILE *f)
  {
  MD5_CTX c;
  unsigned char md[MD5_DIGEST_LENGTH];
  int fd;
  int i;
  static unsigned char buf[BUFSIZE];

  fd=fileno(f);
  MD5_Init(&c);
  for (;;)
    {
    i=read(fd,buf,BUFSIZE);
    if (i <= 0) break;
    MD5_Update(&c,buf,(unsigned long)i);
    }
  MD5_Final(&(md[0]),&c);
  pt(md);
  }

void pt(unsigned char *md)
  {
  int i;

  for (i=0; i<MD5_DIGEST_LENGTH; i++)
    printf("%02x",md[i]);
  printf("\n");
  }

md5.h

#ifndef HEADER_MD5_H
#define HEADER_MD5_H

#include <openssl/e_os2.h>
#include <stddef.h>

#ifdef  __cplusplus
extern "C" {
#endif

#ifdef OPENSSL_NO_MD5
#error MD5 is disabled.
#endif

/*
 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 * ! MD5_LONG has to be at least 32 bits wide. If it's wider, then !
 * ! MD5_LONG_LOG2 has to be defined along.         !
 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 */

#if defined(__LP32__)
#define MD5_LONG unsigned long
#elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__)
#define MD5_LONG unsigned long
#define MD5_LONG_LOG2 3
/*
 * _CRAY note. I could declare short, but I have no idea what impact
 * does it have on performance on none-T3E machines. I could declare
 * int, but at least on C90 sizeof(int) can be chosen at compile time.
 * So I've chosen long...
 *          <[e-mail]>
 */
#else
#define MD5_LONG unsigned int
#endif

#define MD5_CBLOCK  64
#define MD5_LBLOCK  (MD5_CBLOCK/4)
#define MD5_DIGEST_LENGTH 16

typedef struct MD5state_st
  {
  MD5_LONG A,B,C,D;
  MD5_LONG Nl,Nh;
  MD5_LONG data[MD5_LBLOCK];
  unsigned int num;
  } MD5_CTX;

int MD5_Init(MD5_CTX *c);
int MD5_Update(MD5_CTX *c, const void *data, size_t len);
int MD5_Final(unsigned char *md, MD5_CTX *c);
unsigned char *MD5(const unsigned char *d, size_t n, unsigned char *md);
void MD5_Transform(MD5_CTX *c, const unsigned char *b);
#ifdef  __cplusplus
}
#endif

#endif

[Jörg W. (dl8dtl) (Moderator)]

Micha schrieb:
> Sorry wenn ich gerade auf dem Schlauch stehe aber wo sind die
> Funktionsdeklarationen für "MD5_Init", "MD5_Update", .... ?

Die Deklarationen habe ich dir doch gezeigt ...

Du meinst vermutlich die Definitionen.  Hmm, hast du denn keinen
grep?

% grep MD5_Init /usr/src/crypto/openssl/crypto/md5/*.c
/usr/src/crypto/openssl/crypto/md5/md5.c:       MD5_Init(&c);
/usr/src/crypto/openssl/crypto/md5/md5_dgst.c:int MD5_Init(MD5_CTX *c)
/usr/src/crypto/openssl/crypto/md5/md5_one.c:   if (!MD5_Init(&c))

Ist also offenbar in md5_dgst.c.

[Micha (Gast)]

Ich bekomme es einfach nicht hin... :-(

Kann mir jemand mal an einem Bsp. zeigen wie das funktionieren soll ?
Also Fkt. Aufruf und Übergabe der umzuwandelnden Daten!

Ich sitze schon den ganzen Tag davor um bin kein Meter weiter gekommen 
:-)

Gruß Micha

[Jörg W. (dl8dtl) (Moderator)]

Ich versteh' ehrlich nicht, was denn daran nun so schwer ist ...

#include <sys/types.h>
#include <openssl/md5.h>
#include <stdio.h>
#include <string.h>

#define STRING "The quick brown fox jumps over the lazy dog.\n"

int
main(void)
{
  MD5_CTX ctx;
  unsigned char digest[16];
  int i;

  MD5_Init(&ctx);
  MD5_Update(&ctx, STRING, strlen(STRING));
  MD5_Final(digest, &ctx);

  for (i = 0; i < 16; i++)
    printf("%02x", digest[i]);
  putchar('\n');

  return 0;
}

(Das bezieht sich auf die OpenSSL-Implementierung, nicht auf die
von mir weiter oben zitierte FreeBSD-Implementierung.  Letztlich
unterscheiden sich die Namen jedoch nur um einen Unterstrich, die
Benutzung ist ansonsten gleich.)

% cc -O -g -o mymd5 mymd5.c -lcrypto
% ./mymd5
0d7006cd055e94cf614587e1d2ae0c8e

Zum Vergleich:

% echo The quick brown fox jumps over the lazy dog. > /tmp/foo
% md5sum /tmp/foo
0d7006cd055e94cf614587e1d2ae0c8e  /tmp/foo

Passt.

[Micha (Gast)]

Danke Jörg !!!!

Soweit bin ich jetzt mal das ich es initialisieren kann, jetzt habe ich 
aber ein anderes Problem.

Ich habe ja 16 HEX Werte die ich umwandel möchte. Wie bekomme ich die am 
elegantesten zu einer Zeichenkette umgewandelt damit ich daraus einen 
Hash Code erzeugen kann.

Im Anschluss muss dieser Hash wieder in ein HEX-Wert umgewandelt werden, 
den ich dann zum abgleich versende.

Ich habe es jetzt mal so ausprobiert, es kommt aber hierbei ein falscher 
Hash-Code raus!

sprintf(hex_to_str, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", sg_data[0], 
sg_data[1], sg_data[2], sg_data[3], sg_data[4], sg_data[5], 
sg_data[6], sg_data[7], sg_data[8], sg_data[9], sg_data[10], 
sg_data[11], sg_data[12], sg_data[13], sg_data[14], sg_data[15]);
  
md5_init(&ctx);
md5_append(&ctx, hex_to_str, strlen(hex_to_str));
md5_finish(digest, &ctx);

sprintf(str_to_hex, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", 
digest[0], digest[1], digest[2], digest[3], digest[4], digest[5], digest[6], digest[7], 
digest[8], digest[9], digest[10], digest[11], digest[12], digest[13], digest[14], digest[15]);

[Rolf Magnus (Gast)]

Micha schrieb:
> Soweit bin ich jetzt mal das ich es initialisieren kann, jetzt habe ich
> aber ein anderes Problem.
>
> Ich habe ja 16 HEX Werte die ich umwandel möchte. Wie bekomme ich die
> am elegantesten zu einer Zeichenkette umgewandelt damit ich daraus
> einen Hash Code erzeugen kann.

Was verstehst du denn unter "HEX Werte"? Hexadezimal ist erstmal nur ein 
Darstellungsformat. Meinst du damit evtl. einfach nur Bytes?

> Ich habe es jetzt mal so ausprobiert, es kommt aber hierbei ein
> falscher Hash-Code raus!
>
> sprintf(hex_to_str, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", sg_data[0],
> sg_data[1], sg_data[2], sg_data[3], sg_data[4], sg_data[5],
> sg_data[6], sg_data[7], sg_data[8], sg_data[9], sg_data[10],
> sg_data[11], sg_data[12], sg_data[13], sg_data[14], sg_data[15]);

Sind sg_data[0 bis 15] tatsächlich Zeiger auf char? Was du mit dieser 
Zeile machst, ist 16 Strings zu einem langen Gesamtstring verketten.

> md5_init(&ctx);
> md5_append(&ctx, hex_to_str, strlen(hex_to_str));

Ich könnte mir vorstellen, du suchst ganz einfach:

md5_append(&ctx, sg_data, 16);

> md5_finish(digest, &ctx);
> sprintf(str_to_hex, 
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
> digest[0], digest[1], digest[2], digest[3], digest[4], digest[5], digest[6], 
digest[7],
> digest[8], digest[9], digest[10], digest[11], digest[12], digest[13], 
digest[14], digest[15]);

[Jörg W. (dl8dtl) (Moderator)]

Micha schrieb:
> Im Anschluss muss dieser Hash wieder in ein HEX-Wert umgewandelt werden,
> den ich dann zum abgleich versende.

Das habe ich ja oben bereits demonstriert, wie man das macht.

[Micha (Gast)]

Vielleicht drücke ich mich etwas unvollständig aus, daher nochmal 
ausführlich:
Ich habe 16 HEX Werte in einem Array (z.b 0x12) die an die Funktion 
hash() übergeben werden und aus diesen soll ein HEX-Hash-Code erstellt 
werden.

Meine Funktion hierzu sieht wie folgt aus, wobei hier aber noch kein 
korrekter Hash erzeugt wird und ich den Fehler einfach nicht finde.

Muss ich denn überhaupt aus dem HEX-Array ein String machen oder geht 
das auch einfacher ?
Was muss verändert werden, damit ich endlich mal was sinnvolles als 
Ergebnis raus bekomme ?
Danke & Gruß Micha

void hash(uint8_t *sg_data)
{
  md5_state_t ctx;
  unsigned char digest[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  unsigned char hex_to_str[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};    // HEX -> STR

  // **** Formatiere HEX Array in einen String ****  ??? notwendig ???
  sprintf(hex_to_str, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", sg_data[0], 
  sg_data[1], sg_data[2], sg_data[3], sg_data[4], sg_data[5], 
  sg_data[6], sg_data[7], sg_data[8], sg_data[9], sg_data[10], 
  sg_data[11], sg_data[12], sg_data[13], sg_data[14], sg_data[15]);
  
  md5_init(&ctx);
  md5_append(&ctx, hex_to_str, strlen(hex_to_str));
  md5_finish(digest, &ctx);

   
  // **** Sende MD5 Hash ****
  send_msg(digest);

  return 0;
}

[Rolf Magnus (Gast)]

Micha schrieb:
> Vielleicht drücke ich mich etwas unvollständig aus, daher nochmal
> ausführlich:
> Ich habe 16 HEX Werte

Also nochmal: Was verstehst du unter "HEX Werte"?

> Muss ich denn überhaupt aus dem HEX-Array ein String machen oder geht
> das auch einfacher ?

Wieso solltest du einen String machen müssen? md5_append erwartet 
offensichtlich ein Array der Bytes, von denen du den Hash bilden willst, 
und du hast ein Array aus Bytes, von denen du den Hash bilden willst. 
Wozu also irgendwelche String-Hantierereien?

> Was muss verändert werden, damit ich endlich mal was sinnvolles als
> Ergebnis raus bekomme ?
> Danke & Gruß Micha
>
> void hash(uint8_t *sg_data)
> {
>   md5_state_t ctx;
>   unsigned char digest[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
>   unsigned char hex_to_str[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};    // HEX -> 
STR
>
>   // **** Formatiere HEX Array in einen String ****  ???

Wie ich schon vermutet habe, ist dein Array nicht "HEX", sondern einfach 
nur ein Array aus Bytes. "Hex" ist eine Form der Darstellung. Wenn du 
von "HEX" schreibst, gehe ich erstmal von einem String aus, in dem eine 
hexadezimale Darstellung eines Wertes steht, z.B. "0x2F". Das hast du 
hier aber gar nicht.

>   sprintf(hex_to_str, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", sg_data[0],
>   sg_data[1], sg_data[2], sg_data[3], sg_data[4], sg_data[5],
>   sg_data[6], sg_data[7], sg_data[8], sg_data[9], sg_data[10],
>   sg_data[11], sg_data[12], sg_data[13], sg_data[14], sg_data[15]);

Eigentlich würde ich erwarten, daß GCC hier 16 Warnungen ausgibt, weil 
die Typen völlig falsch sind. Du interpreterst hier jedes Element (also 
jedes Byte) von sg_data als einen Zeiger auf einen String. Und diese 16 
Strings versuchst du mit dem Code zu einem langen Gesamtstring zu 
verketten. Dabei kommt natürlich kompletter Unsinn raus.

>   md5_init(&ctx);
>   md5_append(&ctx, hex_to_str, strlen(hex_to_str));

Mein Vorschlag hat nicht funktioniert?

>   md5_finish(digest, &ctx);
>
>
>   // **** Sende MD5 Hash ****
>   send_msg(digest);
>
>   return 0;
> }

[Micha (Gast)]

Hallo Rolf,

leider hat dein Vorschlag nicht die erhofften Lösung gebracht.
Ich habe jetzt nochmal drüber geschaut und paar Fehler gefunden.
Also "md5_append" verlangt ein Array (siehe unten) das habe ich jetzt 
auch verstanden :-) Ich habe jetzt auch alle Datentypen angepasst (hatte 
1-2 anstatt "md5_byte_t = unsigned char" als uint8_t definiert.

Leider funktioniert die Umwandlung noch immer nicht korrekt.
Die verbesserte Hash-Funktion steht ganz unten.

/* Initialize the algorithm. */
void md5_init(md5_state_t *pms);

/* Append a string to the message. */
void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);

/* Finish the message and return the digest. */
void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);

void hash(md5_byte_t *sg_data)
{
  md5_state_t ctx;
  md5_byte_t digest[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  
  md5_init(&ctx);
  md5_append(&ctx, sg_data, 16);
  md5_finish(&ctx, digest);

  set_hash_msg(digest);  // Fertigen Hash in Botschaftsrahmen übertragen
  
  // **** Sende MD5 Hash ****
  send(digest);

  return 0;
}

[Micha (Gast)]

Ich habe gerade bemerkt das bei dem Funktionsaufruf "md5_append(&ctx, 
sg_data, 16);" an Stelle sg_data der Datentyp "md5_byte_t" übergeben 
wird und nicht der erwartete "const md5_byte_t".
Kann das ein Problem sein ?

[Jörg W. (dl8dtl) (Moderator)]

Micha schrieb:

> /* Initialize the algorithm. */
> void md5_init(md5_state_t *pms);
>
> /* Append a string to the message. */
> void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
>
> /* Finish the message and return the digest. */
> void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);

Warum deklarierst du diese selbst?  Dafür gab's doch bei OpenSSL schon
ein Headerfile.

>   md5_byte_t digest[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

Die Initialisierung ist flüssiger als Wasser.  (Ganz davon
abgesehen, "md5_byte_t digest[16] = {0};" hätte den gleichen
Effekt.)

Was an diesem Code noch falsch sein soll, kann dir so allerdings
niemand sagen.  Vielleicht gibst du uns ja mal die 16 Bytes und den
dafür von dir erwarteten Hashwert?

Micha schrieb:
> Ich habe gerade bemerkt das bei dem Funktionsaufruf "md5_append(&ctx,
> sg_data, 16);" an Stelle sg_data der Datentyp "md5_byte_t" übergeben
> wird und nicht der erwartete "const md5_byte_t".
> Kann das ein Problem sein ?

Nein, natürlich nicht.  Das "const" da besagt nur, dass die aufgerufene
Funktion am Inhalt, auf den der Zeiger zeigt, nichts zu ändert gedenkt.

[Micha (Gast)]

Jörg Wunsch schrieb:
> Warum deklarierst du diese selbst?  Dafür gab's doch bei OpenSSL schon
> ein Headerfile.

Mach ich doch garnicht... habe dafür eine fertige *.h udn *.c File 
genommen.
Download: 
http://sourceforge.net/projects/libmd5-rfc/files/libmd5-rfc/2002-04-13/md5.tar.gz/download

> Was an diesem Code noch falsch sein soll, kann dir so allerdings
> niemand sagen.  Vielleicht gibst du uns ja mal die 16 Bytes und den
> dafür von dir erwarteten Hashwert?

Die zu übergebenen Bytes ändern sich ständig und somit auch der zu 
erwartende Hash. Daher kann ich auch kein Beispiel aufzeigen.

Werde noch etwas rumprobieren und den Erfolg/Misserfolg dann posten !

Thx, Micha

[Jörg W. (dl8dtl) (Moderator)]

Micha schrieb:

> Die zu übergebenen Bytes ändern sich ständig und somit auch der zu
> erwartende Hash. Daher kann ich auch kein Beispiel aufzeigen.

Irgendwoher musst du doch aber wissen, dass deine bisherigen Rechnung
nicht stimmt.  Wie willst du das denn ermitteln, wenn nicht mit einem
Beispiel?

[michael (Gast)]

Ist zwar schon uralt der Thread, aber ich habe auch gerade versucht die 
anfangs erwähnte libmd5-rfc (http://sourceforge.net/projects/libmd5-rfc) 
von L. Peter Deutsch zu verwenden. Und bin dabei auf diese Seite 
gelangt. ;-)

Ich habe es hinbekommen und vielleicht hilft es ja noch dem ein oder 
anderen hier. Oder jemandem der, wie ich, durch suchen auf diese Seite 
kommt.

#include "md5.h"
#include <math.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
        int i;
        char text[] = "hallo";
        md5_state_t state;
        md5_byte_t digest[16];

        md5_init(&state);
        md5_append(&state, (const md5_byte_t *)text, strlen(text));
        md5_finish(&state, digest);

        printf("md5 hash of string %s = ", text);
        for(i=0; i < 16; i++)
        {
            printf("%02x", digest[i]);
        }
        printf("\n");

        return 0;
}

[Joe F. (easylife)]

Gratulation.
Du hast mich jetzt gerade dazu gebracht 10 Minuten lang einen 4 Jahre 
alten Deppen-Thread zu lesen, nur um am Ende zu erfahren, dass du deinen 
großartigen Programmier-Erfolg kundtun wolltest.

Danke dafür.

[r_u_d_i (Gast)]

und ich wollte von 2011 micha grad fragen was in
sg_data[x] steht , der hex oder das char also 0x31 oder '1'
;-)

man man man die kellerleichen immer
aber gut , es gibt dann also eine lösung

prima! gut gemacht michael,
bist du der micha aus 2011 und es hat jetzt 4 jahre gedauert?

;-)

lg rudi ;-)

[Bitflüsterer (Gast)]

DER Wahnsinn, Mann!

Nach vier Jahren hast Du also geschafft, einen Code anzuwenden. Respekt.
Wir haben auch nur ca. 50.000 Jahre gebraucht, um, nach Deinen 
Vorfahren, ein Genie wie Dich zu gebären, aufzuziehen und am Leben zu 
erhalten. Aber das Ergebnis rechtfertigt die ganzez Mühen. Ach! Ich 
hätte da noch ein Gurkenglas, das ich nicht aufkriege. Könntest Du bitte 
mal ... Das wäre nett.

[R. W. (Gast)]

;-)
> hätte da noch ein Gurkenglas, das ich nicht aufkriege.
> Könntest Du bitte mal

mit einem löffel an der seite anheben dann geht auch hier die luft raus 
wie im thread ;-)
...
moin moin

[Mark B. (markbrandis)]

Bitflüsterer schrieb:
> Nach vier Jahren hast Du also geschafft, einen Code anzuwenden.

Das steht so nirgends. Wer lesen kann, ist klar im Vorteil.

[Karl H. (kbuchegg)]

Ich mach dann mal dicht.