#include <iostream>

int main() {

    std::cout << "Goodbye World" << std::endl; // Da sowieso die Welt untergeht, erlaubt man sich den uberflüssen flush!

    return 666;

}

Da sowieso die Welt untergeht, dürfen die Mods auch nutzlose Threads stehen lassen! :xmas1:

Die Welt message

ja dann wünsch euch ein schönes untergehen

gruß
coco

#include <stdio.h>

using namespace std;

void main()
{
  printf ("Goodbye World\n");
}

#include <stdio.h>

int main()
{
char hello_world[12];
hello_world[0] = 'h';
hello_world[1] = 'e';
hello_world[2] = 'l';
hello_world[3] = 'l';
hello_world[4] = 'o';
hello_world[5] = ' ';
hello_world[6] = 'w';
hello_world[7] = 'o';
hello_world[8] = 'r';
hello_world[9] = 'l';
hello_world[10] = 'd';
hello_world[11] = '\0';

int i;
for(i=0;i<=11;i = i + 1)
printf(%c,hello_world[i]);
return0;

}

#include <string.h>
#include <iostream>

char *GetGBWorldString() { //inspired by my hero JW
  char str[]="Goodbye World!\n";
  return str;
}

void main() {
  int *pointless=new int[1000];
  std::cout << GetGBWorldWtring() << std::endl;
  system("pause");
}

#include <iostream>

typedef int HELL;
typedef int METEOR;

int main()
{
int(*ByeBye)(const char* );
ByeBye = ( int(*)(const char*) ) std::printf;

HELL* MEMORY_OF_DOOM;
METEOR METEORSHOWER=1;

  while(1)
  {
      ByeBye("\x47\x4f\x4f\x44\x42\x59\x45\x20\x57\x4f\x52\x4c\x44\x20\x21\n");
      MEMORY_OF_DOOM = new HELL [ METEORSHOWER ];
      METEORSHOWER++;
  }
}

#include <iostream>
using namespace std;
int main {
cout << "Siehe hier: http://hisz.rsoe.hu/alertmap/index2.php << endl;
cout << "Und hier: http://21dezember2012.org" << endl;
return "Weltuntergang 2012";
}

0x0Weltuntergang :xmas1:

#include<cstdio>

              //
             /**/
           template
        <int I,int I_>
       struct _{enum{_I=
     (I==1+1)||(I%I_)&&_<(
    I_>1/2+2?I:1/2),I_-1>::
  _I};};template<>struct _<1-
          1,1/3>{enum
        {_I=0+1};};int 
      I=1*0;void i(int I
    ){if(I>=1){if(::I<27){
  putchar(::I["*F@lkA^!Zp?Z~\
\023|HX^`$X(N+\011#\360"]+::I)
        ;}::I+=1+1;i
      (I-1);}}template<>
     struct _<-5/6,1>{enum 
   {_I=1+1-1};};template<int 
i>struct __{__<i-1> I;enum{_I=_
      <i,i-1>::_I};void
    _(){I._();if(_I){++::I
  ;::i(i);::I-=0+1+1-0*1;}}}
;template<>struct __<1>{enum {_I
          =0};void
          _(){};};
          int main
          (){__<7>
          _;_._();
}

:xmas1:

:xmas2: Viel Spaß beim Knobeln! :xmas2:

P.S.: Der Code ist teilweise Whitespacesensitiv! Zum Ausprobieren nicht die Formatierung ändern sondern genau so übernehmen!

Das macht mir alles noch nicht genug Stimmung! Außerdem kann ich immer noch die ASCII-Zeichen sehen, auch wenn sie in HEX-stehen. Das ist doch keine Obfuscation. So geht das:

#include<cstdio>

              //
             /**/
           template
        <int I,int I_>
       struct _{enum{_I=
     (I==1+1)||(I%I_)&&_<(
    I_>1/2+2?I:1/2),I_-1>::
  _I};};template<>struct _<1-
          1,1/3>{enum
        {_I=0+1};};int 
      I=1*0;void i(int I
    ){if(I>=1){if(::I<27){
  putchar(::I["*F@lkA^!Zp?Z~\
\023|HX^`$X(N+\011#\360"]+::I)
        ;}::I+=1+1;i
      (I-1);}}template<>
     struct _<-5/6,1>{enum 
   {_I=1+1-1};};template<int 
i>struct __{__<i-1> I;enum{_I=_
      <i,i-1>::_I};void
    _(){I._();if(_I){++::I
  ;::i(i);::I-=0+1+1-0*1;}}}
;template<>struct __<1>{enum {_I
          =0};void
          _(){};};
          int main
          (){__<7>
          _;_._();
}

:xmas1:

:xmas2: Viel Spaß beim Knobeln! :xmas2:

Nett, aber bei jkghj stehen gar keine ASCII Zeichen?

Nett, aber bei jkghj stehen gar keine ASCII Zeichen?

Oh, den hatte ich noch gar nicht gesehen. Ich bezog mich auf DrakoXP und Marthog, die mich zu meiner Lösung inspirierten (die übrigens intern ähnliche Ideen wie jkghj benutzt, bloß nochmal eine Stufe komplizierter).

P.S.: jkghj's Lösung funktioniert bei mir nicht . Weder mit unsigned-char noch signed-char.

Wird da evtl. UB hervorgerufen?

int main()
{
	char arr[9] = {2, 30, 41, 40, 0, -11, -2, 23, -20};

	while (arr[0] < 9)
		std::cout<< (arr[arr[0]] += arr[arr[0]++ - 1]);
}

Da das ganze ja eh unter dem Motto Weltuntergang steht, ist das ja egal, aber mich würde es wirklich interessieren, was da schief läuft.

int main()
{
    char arr[9] = {2, 30, 41, 40, 0, -11, -2, 23, -20};

    for (;arr[0] < 9; ++arr[0])
        arr[arr[0]] += arr[arr[0] - 1];

	std::cout.write(arr + 2, 7);
}

Sollte es bei dir so gehen, dann war das ++arr[0] wohl schuld?

#include <cstdio>
#include <iostream>

template<int I, int I_>
struct _
{
    enum
    { _I =    (I == 1)
           ||   ((I % I_)
             && _ <( I_> 2? I : 0 ), I_ - 1>::_I) };
};

template<> struct _<0, 0> { enum { _I = 1}; };
template<> struct _<0, 1> { enum { _I = 1}; };

int I = 0;
void i(int I)
{
    if(I >= 1)
    {
        if(::I < 27)
        {
          putchar(::I[" Goodbye World!"]);
        }
        ::I += 1;
        i(I-1);
    }
}

template<int i>
struct __
{
    __<i-1> I;
    enum
    { _I = _<i, i-1>::_I };

    void _()
    {
        I._();
        if(_I)
        {
            ++::I;
            ::i(i);
            ::I -= 1;
        }
    }
};

template<>
struct __<1>
{
    enum { _I = 0 };

    void _(){}
};

int main()
{
    __<7>()._();
}

Sollte es bei dir so gehen, dann war das ++arr[0] wohl schuld?

Ja so geht es. ABer das liegt nicht an meinem Computer, das war eben schlichtweg ein Konstrukt der Form i = i++ , das ist eben einfach undefiniert. Das iwrd vermutlich sogar bei dir selber schon nicht mehr funktionieren, wenn du irgendetwas an den Compilereinstellungen änderst, z.B. Optimierung einschaltest.

Ich war zuerst verwirrt, da der Code nämlich auch (sogar immer noch) die Warnung "array subscript has type ‘char’" wirft. Diese Warnung gibt es nämlich wegen möglichen Problemen der signedness. Aber der Code funktioniert nun trotzdem, egal ob mit signed oder unsigned char.

Die String Verschlüsselung und der Trick mit den Integerdivisionen war lahm, da hättest du dir mehr Mühe geben sollen :xmas1:

Woot? Ich glaube dir nicht, dass du die Stringverschlüsselung geknackt hast. Du hast geraten. Erklär mal das Verfahren.

P.S.: Ja, die Integerdivision war lahm. Ich musste Zeichen schinden, damit der Weihnachtsbaum gut aussieht :xmas1: . Aber die Stringverschlüsselung ist nicht einfach eine komplizierte Darstellung von "Goodbye World", die ist viel cleverer. Das sieht man daran, dass dein "deobfuscated" Programm zwar die Entschlüsselungsalgorithmen noch enthält, aber nicht benutzt.

Aber um dich nicht zu enttäuschen werde ich es jetzt zu verstehen versuchen.

Fangen wir hier an:

::I[ "*F@lkA^!Zp?Z~\\023|HX^`$X(N+\011#\360" ] + ::I

Das nte Zeichen wird immer n Zeichen vorverschoben. Also muss es für den Endtext n Zeichen zurückverschoben worden sein.

"*GBooFd(byIeè èWhor7l=dB!<"

Nimmt man dann die offensichtlich vom Algorithmus ignorierten Zeichen weg, so ergibt sich

"*GBooFd(byIeè èWhor7l=dB!<"
" G oo d by e Whor l d ! "
"012345678901234567890123456

Edit: Das war falsch eingerückt, muss nochmal nachdenken

Das ganze läuft hier an:

if(::_<i, i-1>::_I) // Prüfung
        {
            ++::I;
            ::i(i); // Ausgabe des Indexes
            --::I;
        }

Soweit richtig?

SeppJ schrieb:

#include<cstdio>

//
/**/
template
<int I,int I_>
struct {enum{I=
(I==1+1)||(I%I)&&<(
I_>1/2+2?I:1/2),I_-1>::
_I};};template<>struct _<1-
1,1/3>{enum
{I=0+1};};int
I=1*0;void i(int I
){if(I>=1){if(::I<27){
putchar(::I["F@lkA^!Zp?Z~\
\023|HX^`$X(N+\011#\360"]+::I)
;}::I+=1+1;i
(I-1);}}template<>
struct _<-5/6,1>{enum
{_I=1+1-1};};template<int
i>struct {<i-1> I;enum{_I=_
<i,i-1>::_I};void
(){I.();if(_I){++::I
;::i(i);::I-=0+1+1-01;}}}
;template<>struct <1>{enum {_I
=0};void
_(){};};
int main
(){<7>
;.();
}

[C++ Fehler] Unit1.c(6): E2141 Fehler in der Deklarationssyntax
[C++ Fehler] Unit1.c(10): E2141 Fehler in der Deklarationssyntax
[C++ Fehler] Unit1.c(15): E2380 Nicht abgeschlossene String- oder Zeichen-Konstante
[C++ Fehler] Unit1.c(15): E2290 Bei Subskription fehlt ]
[C++ Fehler] Unit1.c(16): E2206 Ungültiges char-Zeichen '\' (0x5c)
[C++ Fehler] Unit1.c(16): E2206 Ungültiges char-Zeichen '`' (0x60)
[C++ Fehler] Unit1.c(16): E2206 Ungültiges char-Zeichen '$' (0x24)
[C++ Fehler] Unit1.c(16): E2206 Ungültiges char-Zeichen '\' (0x5c)
[C++ Fehler] Unit1.c(16): E2206 Ungültiges char-Zeichen '#' (0x23)
[C++ Fehler] Unit1.c(16): E2206 Ungültiges char-Zeichen '\' (0x5c)
[C++ Fehler] Unit1.c(16): E2380 Nicht abgeschlossene String- oder Zeichen-Konstante
[C++ Fehler] Unit1.c(18): E2141 Fehler in der Deklarationssyntax
[C++ Fehler] Unit1.c(20): E2141 Fehler in der Deklarationssyntax
[C++ Fehler] Unit1.c(25): E2141 Fehler in der Deklarationssyntax
[C++ Fehler] Unit1.c(29): E2451 Undefiniertes Symbol '__'
[C++ Fehler] Unit1.c(30): E2451 Undefiniertes Symbol '_'
[C++ Warnung] Unit1.c(31): W8070 Funktion sollte einen Wert zurückgeben

Aber er sieht aus.

Sowas müsste man mal in einem Projekt benutzen da freut sich doch der jenige der den Code eventuell mal "umschreiben" müsste.

Aber um dich nicht zu enttäuschen werde ich es jetzt zu verstehen versuchen.

Ich denke, das ist unmöglich, das Verfahren ist viel zu obskur. Du hast das richtige Hackervorgehen gezeigt: Anstatt den unlesbaren Kopierschutz zu entschlüsseln, hast du einfach deinen eigenen Code an die Stelle gesetzt, der alles überspringt .

Wenn es dich interessiert, wie es geht:
Spoiler

P.S.: Ich sehe, du hast es doch fast alleine gelöst

Der Tannenbaum kompiliert nicht !

Hast du den Code auch kopiert ohne die Formatierung zu ändern? Kritisch ist die Stelle

putchar(::I["*F@lkA^!Zp?Z~\
\023|HX^`$X(N+\011#\360"]+::I)

Da hier das Zeilenfortsetzungszeichen '\' benutzt wird, darf da kein falsches Zeichen an den Anfang der nächsten Zeile. Diese muss unbedingt mit dem \023 beginnen!
Du kannst natürlich auch

#include<cstdio>

              //
             /**/
           template
        <int I,int I_>
       struct _{enum{_I=
     (I==1+1)||(I%I_)&&_<(
    I_>1/2+2?I:1/2),I_-1>::
  _I};};template<>struct _<1-
          1,1/3>{enum
        {_I=0+1};};int
      I=1*0;void i(int I
    ){if(I>=1){if(::I<27){
  putchar(::I["*F@lkA^!Zp?Z~\023|HX^`$X(N+\011#\360"]+::I)
        ;}::I+=1+1;i
      (I-1);}}template<>
     struct _<-5/6,1>{enum
   {_I=1+1-1};};template<int
i>struct __{__<i-1> I;enum{_I=_
      <i,i-1>::_I};void
    _(){I._();if(_I){++::I
  ;::i(i);::I-=0+1+1-0*1;}}}
;template<>struct __<1>{enum {_I
          =0};void
          _(){};};
          int main
          (){__<7>
          _;_._();
}

benutzen, dann kannst du umformatieren wie du möchtest und es sollte überall funktionieren (ja, streng genommen ist der Bezeichner _ und _I reserviert, aber ich gehe mal davon aus, dass dieser in keiner Standardbibliothek benutzt wird)