Quell-Code verstecken/verschleiern

[Rangi J. (rangi)]

Hallo Forum,
ich möchte meinen Quellcode gerne verstecken oder verschleiern. 
Folgender Hintergrund: mein Quellcode soll Teil eines größeren Projektes 
werden, welches von anderen Leuten erzeugt wird. Ich liefere also 
Objekt-Files, die dann von denen gelinkt und auch debugt werden. Wie 
stelle ich es am besten an, das dabei nichts aus meinem Quellcode 
zusehen ist.
Typischerweise sieht man dabei ja die Variablen-Namen und die 
Funktionsnamen, die zzt. einigermaßen Aussagekräftig sind. Das möchte 
ich verhindern. Gibts hier Tools oder wie macht ihr das?
Es geht um GCC für AVR.

[(prx) A. K. (prx)]

Diese Leute sollen also Debuggen dürfen, aber die Funktion und Benennung 
der Interface-Funktionen nicht kennen dürfen?

[Karl H. (kbuchegg)]

Rangi Jones schrieb:

> Ich liefere also
> Objekt-Files, ....

> Typischerweise sieht man dabei ja die Variablen-Namen und die
> Funktionsnamen,

Das würde ich gerne mal life sehen, wie man aus einem Object-File, 
welches nicht debug compiliert wurde, das alles über die interne 
Struktur rauskriegt.

Die Funktionsnamen der lokalen Funktionen sind vielleicht noch 
vorhanden, wenn der Compiler nicht inlinen konnte. Aber die sind so 
hilfreich, wie das Inhaltsverzeichnis von "Krieg und Frieden", wenn es 
um den Inhalt geht.

[Dr. Sommer (Gast)]

komplett fertig compilieren, als binary ausliefern, die Einsprungpunkte 
mit einem Header definieren, ein Script basteln was die Binaries 
"kombiniert". Sie werden dich hassen.

[Rangi J. (rangi)]

@A.K.
naja, soviel Verständnis hab ich dem Leser in dem Forum schon zugetraut. 
Die Zugriffsfunktionen sind logischweise lesbar und auch dokumentiert. 
Es geht darum, jegliche interne Funktionalität zu verschleiern.

@Karl Heinz
Die Details aus einzelnen Funktionen sind garnicht so wichtig. Es geht 
nicht nur um ein paar Funktionen in einem Modul. Es ist ein bisschen 
mehr und dann ist es dem böswilligen Debugger durchaus von nutzen, zu 
wissen was ich denn so anstelle mit der Hardware und in welcher 
Reihenfolge.
Wenn zb. die Funktion memcpy heisst muss ich garnicht wissen wie sie es 
genau macht, der Name verrät schon alles.

[Rangi J. (rangi)]

@Dr. Sommer:
auf so eine Idee bin ich auch schon gekommen, aber leider geht das 
nicht. Der fertige Code geht über die 128kB-Grenze hinaus. Dafür 
verwendet AVR diese blöden Trampolins. Dadurch kann ich nicht dynamisch 
(also nach dem Linken) die Adressen von fremdem Funktionen mehr ändern.
Aber ja, für 32-Bitter würde das funktionieren. Leider keine Option.

[Dr. Sommer (Gast)]

Rangi Jones schrieb:
> Dadurch kann ich nicht dynamisch
> (also nach dem Linken) die Adressen von fremdem Funktionen mehr ändern.
Ich meinte ja auch vor dem Linken. Du musst dem User Code halt durch ein 
bisschen Linker-Magic die Adressen fix mitgeben.

[OldMen (Gast)]

Rangi Jones schrieb:
> stelle ich es am besten an, das dabei nichts aus meinem Quellcode
> zusehen ist.

Wenn jeder so denken würde, hätten wir heute keine GNU-Tools, Linux, 
usw.
Bewerbe Dich doch beim NSA, die brauchen so Leute.

[Kollege (Gast)]

OldMen schrieb:
> Wenn jeder so denken würde, hätten wir heute keine GNU-Tools, Linux,
> usw.
> Bewerbe Dich doch beim NSA, die brauchen so Leute.

Vor allem ist der Code den Aufwand meistens gar nicht Wert...

[Horst (Gast)]

OldMen schrieb:

> Bewerbe Dich doch beim NSA, die brauchen so Leute.

Woher weißt du das?

[Rangi J. (rangi)]

@Dr. Sommer
das hört sich Intressant an. Mal sehen ob ichs richtig verstanden habe.
Ich baue eine Dummy-Umgebung, die alle meine Funktionen referenziert 
zusammen mit meinem Code. Dann trenne ich im hex-File Dummy von meinem 
Code.
Jetzt gebe ich meinen Teil des hex-files und eine Liste der Funktionen 
nach außen. Die andrern müssen dann ihren Code woanders hin legen, dann 
linken und danach die Hex-Files zusammenbauen.
Call-Backs würde ich dann über Funktions-Pointer per Übergabe erledigen.
Wie kann ich dem Linker (also dann beim fertigen System) sagen, dass auf 
Adresse 0xabcd eine Funkion ist, die er nicht kennt und auch nicht 
platziert?

[Rufus Τ. F. (rufus)]

Karl Heinz schrieb:
> Die Funktionsnamen der lokalen Funktionen sind vielleicht noch
> vorhanden

Wenn sie als static deklariert wurden, sollte das nicht der Fall sein.

[Winfried J. (Firma: Nisch-Aufzüge) (winne)]

hallo
Bastel doch eine Publicfunktion welche die Parameter und die gewünschte 
Aufgabe vom User übernimmt. Selbige legt diese Daten auf eine internee 
inbox welche von deinen bereits compilierten und assemblierten 
Funktionen abgearbeitet wird. Anschließend übergibst du das Ergebnis 
über eine ebensolche Schleuse Retur. Somit kannst du fertige 
maschinecode verwenden.
Interne Variablen und Funktionen kannst du mit suchen und ersetzen zuvor 
durchnummerieren. Variableninhalte (strings) vor dem ablegen und nach 
dem auslesen bitrotieren. So ist selbst das Speicherabbid nicht mehr 
ohne Aufwand auswertbar, da kein Klartext mehr zurückbleibt. IN und OUT 
lassen sich auch vor und nach der verarbeitung grundsaätzlich rotiern, 
so dass Bitmuster aus Vergleichs oder bedingten Operationen nicht mit 
den Bitmustern an den Ports korrospondieren.

Mehr Verschleierung braucht es nicht Scriptkiddis aufzuhalten anders bei 
guten Hackern, die lassen sich auch von selbstmodifizierendem Code nicht 
aufhalten. Sondern knacken aus olympischen Ehrgeiz, egal wie hoch der 
Aufwand ist.
Namaste

[Johann L. (gjlayde)]

Du könntest all deine Module relocatable zusammenlinken (-r); dadurch 
werden bekannte Symbole aufgelöst.  Evtl. ist es zweckmäßig, alle Module 
zusammen zu compilieren, d.h. in einem Aufruf; alternativ mit LTO 
(-flto) compilen und linken.

Wie man unterschiedlichen globalen Symbole, d.h. "extern (für Kunde) 
sichtbar" und "nur für dich sichtbar zur Intermodul-Kommunikation" 
unterschiedlich handhabt, hab ich jetzt keine Idee...

Zum einen sollten von "deinen" Symbolen nach dem -r Linken keine mehr 
verbleiben, zum anderen könntest du mit Sichtbarkeit experimentieren 
(etwa attribute visibility auf "hidden" oder "externally_visible").

[Johann L. (gjlayde)]

...und Strukturen, auf die der Anwender nicht direkt zugreifen muß, 
kannst du incomplete machen, d.h. im ausgelieferten Header steht nur ein 
"struct foo;" oder "union bar;" oder gar "typedef bazz;".

Damit kann der Anwender Zeiger auf dieses Zeug umherschuben und 
vergleichen, aber nicht dereferenzieren.  Du brauchst also (öffentliche) 
Zugriffsfunktionen.

[Jasch (Gast)]

Rangi Jones schrieb:
> Hallo Forum,
> ich möchte meinen Quellcode gerne verstecken oder verschleiern.
> Folgender Hintergrund: mein Quellcode soll Teil eines größeren Projektes
> werden, welches von anderen Leuten erzeugt wird. Ich liefere also
> Objekt-Files, die dann von denen gelinkt und auch debugt werden. Wie
> stelle ich es am besten an, das dabei nichts aus meinem Quellcode
> zusehen ist.

Gib den Funktionen, Variablen etc. Namen nach dem Muster "f1", "f2", 
"v1", "v2" usw. Viel Spass damit...

> Typischerweise sieht man dabei ja die Variablen-Namen und die
> Funktionsnamen, die zzt. einigermaßen Aussagekräftig sind. Das möchte
> ich verhindern. Gibts hier Tools oder wie macht ihr das?
> Es geht um GCC für AVR.

Hmm, hmm, also kann der Code nicht so gigantisch gross sein, also kann 
man realistisch die komplette Funktion aus dem Maschinencode ermitteln 
(dass das auch ganz ohne irgendwelche Bezeichner geht ist klar?).

Da gibt es dann ein paar Fälle zu unterscheiden:

- die anderen Leute sind ein kleine Firma
    - Du vertraust denen -> kein Problem
    - Du vertraust denen nicht
        - Du denkst sie haben nicht die Kapazitäten um den Maschinencode 
zurückzuverwandeln -> kein Problem, aber Du kannst Dich irren
        - Du denkst sie könnten Reverse Engineering machen
            - Du hast einen Anwalt der einen ordentlichen Vertrag 
aufsetzt -> kein Problem, Du kannst im Falle eines Falles vor Gericht 
Recht bekommen, oder auch nicht ;-)
            - Ein ordentlicher Vertrag ist keine Option -> arbeite nicht 
mit denen zusammmen

- die anderen Leute sind eine grosse Firma
    - Deine Wahl, Du hast aber im Falle eines Falles keine Chance weil 
die viel mehr Geld für Anwälte haben

- die zahlen Dir genug Geld dass Du Dir keine Gedanken mehr um das ganze 
Problem machen musst -> kein Problem

Ist doch nicht so schwer? Grins.

[Karl H. (kbuchegg)]

Rangi Jones schrieb:

> mehr und dann ist es dem böswilligen Debugger durchaus von nutzen, zu
> wissen was ich denn so anstelle mit der Hardware und in welcher
> Reihenfolge.

Und was soll den 'böswilligen Debugger' daran hindern, einen 
Logikanalysator an die Pins zu hängen?

> Wenn zb. die Funktion memcpy heisst muss ich garnicht wissen wie sie es
> genau macht, der Name verrät schon alles.

Und das hilft jetzt jemandem im Komplettzusammenhang des Verständnisses 
deiner Funktionen genau wie, dass er weiß dass da ein paar bytes durch 
die Gegend kopiert werden? Diese Funktionalität kommt in so ziemlich 
jedem Programm vor. Genauso wie strcpy, strcat, strtok, ... das ganze 
Repertoire der Standard-Library. Das ist ungefähr so interessant, wie 
die Information dass der nächste Mercedes-Erlkönig höchst wahrscheinlich 
einen Motor haben wird und, uh - oh, Scheibenwischer.


Lieschen Müller kannst du damit aufhalten. Aber die könnte mit den 
Informationen sowieso nichts anfangen. Wers unbedingt wissen will, 
findet es auch heraus. Und die kannst du nicht aufhalten.

[Boot_loader (Gast)]

Ohne alles gelesen zuhaben, der Begriff der hier gesucht wird nennt sich 
Obfuscating!

Einfach mal nach Beispielen suchen und den Wikipedia Artikel lesen. 
Sollte das seinw as du suchst.

http://de.wikipedia.org/wiki/Obfuscator

[Karl H. (kbuchegg)]

Kollege schrieb:

> Vor allem ist der Code den Aufwand meistens gar nicht Wert...

Hab lange überlegt, ob ich diesen Gedanken aufgreifen soll. Denn dann 
kommen wieder die 'Ihr kennt mich doch gar nicht - wie könnt ihr so 
gemein sein' Vorwürfe.

Genau so siehts aus.
Wer in der Lage ist, Code zu schreiben, dessen Aufbau und Funktion 
komplex und interessant genug ist, dass sich jemand Unbefugter dafür 
interessiert, der weiß auch, wie er ihn ein bischen verschleiern kann, 
bzw. schon alleine dadurch, dass er eine saubere opaque Schnittstelle 
und Information Hiding betreibt, versteckt er die Details im Inneren des 
Codes, die der Applikationsprogrammierer nicht sehen soll bzw. sehen 
braucht.

Und im Zweifelsfall ist es als Applikationsprogrammierer von Vorteil, 
sich die Internals ansehen zu können. Schon alleine aus dem Grund 
rausfinden zu können, warum das '*&%$§ wieder mal nicht funktioniert und 
was schief geht.

[900ss (900ss)]

Rangi Jones schrieb:
> ich möchte meinen Quellcode gerne verstecken oder verschleiern


Boot_loader schrieb:
> Ohne alles gelesen zuhaben, der Begriff der hier gesucht wird nennt sich
> Obfuscating!

Richtig.
Ich habe eine Weile mit einer Library aus den USA gearbeitet. Diese 
Library lag als obfuscated 'C' Sourcecode vor. Ich habe die gefragt, 
womit sie das machen..... siehe Link, ist Freeware. Dann kannst du 
getrost den Source weiter geben, da siehst du nix mehr.
Der Compiler übersetzt das aber das ein Mensch das lesen kann ist 
äußerst unwahrscheinlich :)

http://www.plexaure.de/cms/index.php?id=cobf


Ein Ausschnitt:

FooXYZMngBarl531=0x6000,FooXYZMngBarl586,FooXYZMngBarl496,
FooXYZMngBarl604,FooXYZMngBarl611=0x7000,FooXYZMngBarl523,
FooXYZMngBarl565,FooXYZMngBarl554,FooXYZMngBarl538,
FooXYZMngBarl532,FooXYZMngBarl589,FooXYZMngBarl476,
FooXYZMngBarl528=0x8000,FooXYZMngBarl458=0x9000,
FooXYZMngBarl502,FooXYZMngBarl498}FooXYZMngBarl75;
FooXYZMngBarm FooXYZMngBarl598(FooXYZMngBarl75 FooXYZMngBarl101,FooXYZMngBard*FooXYZMngBarl65, FooXYZMngBara FooXYZMngBarl96);FooXYZMngBarb FooXYZMngBarl42
{FooXYZMngBarl473=0x0000,FooXYZMngBarl606=0x0001,
FooXYZMngBarl466=0x0100,FooXYZMngBarl519,FooXYZMngBarl534,
FooXYZMngBarl493,FooXYZMngBarl603,FooXYZMngBarl507,
FooXYZMngBarl615,FooXYZMngBarl478,FooXYZMngBarl489,
FooXYZMngBarl497,FooXYZMngBarl544,FooXYZMngBarl483,
FooXYZMngBarl512=0x0200,FooXYZMngBarl546,FooXYZMngBarl547,
FooXYZMngBarl582,FooXYZMngBarl563,FooXYZMngBarl494=0x0300,
FooXYZMngBarl610,FooXYZMngBarl616=0x0400,FooXYZMngBarl514,
FooXYZMngBarl577,FooXYZMngBarl479,FooXYZMngBarl472=0x04C0,
FooXYZMngBarl530=0x04C0,FooXYZMngBarl468,FooXYZMngBarl568,
FooXYZMngBarl510,FooXYZMngBarl548,FooXYZMngBarl511=0x0500,
FooXYZMngBarl579}FooXYZMngBarl508;FooXYZMngBard
FooXYZMngBarl539(FooXYZMngBara FooXYZMngBarl469);
FooXYZMngBara FooXYZMngBarl578(FooXYZMngBard);FooXYZMngBard
FooXYZMngBarl558(FooXYZMngBara FooXYZMngBarl605);
FooXYZMngBarm FooXYZMngBarl600(FooXYZMngBard);FooXYZMngBarm
FooXYZMngBarl555(FooXYZMngBarl45*FooXYZMngBarl170);
FooXYZMngBard FooXYZMngBarl581(FooXYZMngBarl45* FooXYZMngBarl170);FooXYZMngBarl104*FooXYZMngBarl540( FooXYZMngBari FooXYZMngBarl45*FooXYZMngBarl77,FooXYZMngBari FooXYZMngBarl164*FooXYZMngBarl492,FooXYZMngBarl177* FooXYZMngBarl187);FooXYZMngBard FooXYZMngBarl520( FooXYZMngBari FooXYZMngBarl45*FooXYZMngBarl77, FooXYZMngBarl104*FooXYZMngBarl174);FooXYZMngBarl105*
FooXYZMngBarl553(FooXYZMngBari FooXYZMngBarl45* FooXYZMngBarl77,FooXYZMngBari FooXYZMngBarl178* FooXYZMngBarl580,FooXYZMngBarl188*FooXYZMngBarl187);
FooXYZMngBard FooXYZMngBarl562(FooXYZMngBari FooXYZMngBarl45  *FooXYZMngBarl77,FooXYZMngBarl105*FooXYZMngBarl174);

[Daniel H. (Firma: keine) (commander)]

900ss D. schrieb:
> Der Compiler übersetzt das aber das ein Mensch das lesen kann ist
> äußerst unwahrscheinlich :)

Im Zweifel kompiliert man es und dekompileirt und disassembliert es 
dann. Code-Obfuscation kann es höchstens erschweren die Funktionsweise 
zu verstehen, einen wirklichen Schutz bietet es hingegen nicht. Im 
schlimmsten Fall interessiert sich der Gegenüber gar nicht für den Code 
sondern baut den Code einfach in sein Projekt ein, solange er weiß, was 
für Parameter er nutzen muss und was er heraus bekommt.

[900ss (900ss)]

Daniel H. schrieb:
> 900ss D. schrieb:
>> Der Compiler übersetzt das aber das ein Mensch das lesen kann ist
>> äußerst unwahrscheinlich :)
>
> Im Zweifel kompiliert man es und dekompileirt und disassembliert es
> dann. Code-Obfuscation kann es höchstens erschweren die Funktionsweise
> zu verstehen, einen wirklichen Schutz bietet es hingegen nicht.

Ja stimmt. Ich wünsch viel Spaß dabei ;)

>Im
> schlimmsten Fall interessiert sich der Gegenüber gar nicht für den Code
> sondern baut den Code einfach in sein Projekt ein, solange er weiß, was
> für Parameter er nutzen muss und was er heraus bekommt.

Das ist wohl war. Aber um gewisse Techniken, die in der SW stecken zu 
schützen, ist es gut (mit Ausnahme von oben).
Hier ging es darum, Algorithmen für Bad Block Managing und Wear Leveling 
bei Flash-Speichern, auf das der SW Hersteller Patente hat, zu schützen.

Wenn das jemand disassembliert und danach dann versteht, dann hat er es 
sich verdient :)

In diesem Fall könnte man genausogut die Flash-Zuriffe tracen. 
Möglichkeiten gibt es immer.

[Daniel H. (Firma: keine) (commander)]

900ss D. schrieb:
> Ja stimmt. Ich wünsch viel Spaß dabei ;)

Ehrlich gesagt ist das nicht so schwer, wenn man die Zielplattform 
kennt. Code-Obfuscation zielt darauf ab das Lesen für Menschen zu 
erschweren. Den Compiler interessiert das herzlich wenig, der optimiert 
alles Redundante und überflüssige weg und am Ende sehen "normaler" und 
verschleierter Code im Binary identisch aus.

900ss D. schrieb:
> Hier ging es darum, Algorithmen für Bad Block Managing und Wear Leveling
> bei Flash-Speichern, auf das der SW Hersteller Patente hat, zu schützen.

Wo ist der Sinn? Wenn man ein Patent darauf hat ist es doch eh schon 
geschützt.

[Detlef K. (adenin)]

900ss D. schrieb:
> Ja stimmt. Ich wünsch viel Spaß dabei ;)

Ich hatte eben Spaß :)
Das sind offensichtlich Deklarationen von Funktionen und Strukturen.
Leider ist das Zeug unvollständig, sonst könnte man es in etwas 
verständliches zurück verwandeln.

  FooXYZMngBarl531=0x6000,
  FooXYZMngBarl586,
  FooXYZMngBarl496,
  FooXYZMngBarl604,
  FooXYZMngBarl611=0x7000,
  FooXYZMngBarl523,
  FooXYZMngBarl565,
  FooXYZMngBarl554,
  FooXYZMngBarl538,
  FooXYZMngBarl532,
  FooXYZMngBarl589,
  FooXYZMngBarl476,
  FooXYZMngBarl528=0x8000,
  FooXYZMngBarl458=0x9000,
  FooXYZMngBarl502,
  FooXYZMngBarl498
}FooXYZMngBarl75;

FooXYZMngBarm FooXYZMngBarl598(FooXYZMngBarl75 FooXYZMngBarl101, FooXYZMngBard *FooXYZMngBarl65, FooXYZMngBara FooXYZMngBarl96);

FooXYZMngBarb FooXYZMngBarl42{
  FooXYZMngBarl473=0x0000,
  FooXYZMngBarl606=0x0001,
  FooXYZMngBarl466=0x0100,
  FooXYZMngBarl519,
  FooXYZMngBarl534,
  FooXYZMngBarl493,
  FooXYZMngBarl603,
  FooXYZMngBarl507,
  FooXYZMngBarl615,
  FooXYZMngBarl478,
  FooXYZMngBarl489,
  FooXYZMngBarl497,
  FooXYZMngBarl544,
  FooXYZMngBarl483,
  FooXYZMngBarl512=0x0200,
  FooXYZMngBarl546,
  FooXYZMngBarl547,
  FooXYZMngBarl582,
  FooXYZMngBarl563,
  FooXYZMngBarl494=0x0300,
  FooXYZMngBarl610,
  FooXYZMngBarl616=0x0400,
  FooXYZMngBarl514,
  FooXYZMngBarl577,
  FooXYZMngBarl479,
  FooXYZMngBarl472=0x04C0,
  FooXYZMngBarl530=0x04C0,
  FooXYZMngBarl468,
  FooXYZMngBarl568,
  FooXYZMngBarl510,
  FooXYZMngBarl548,
  FooXYZMngBarl511=0x0500,
  FooXYZMngBarl579
}FooXYZMngBarl508;

FooXYZMngBard FooXYZMngBarl539(FooXYZMngBara FooXYZMngBarl469);

FooXYZMngBara FooXYZMngBarl578(FooXYZMngBard);

FooXYZMngBard FooXYZMngBarl558(FooXYZMngBara FooXYZMngBarl605);

FooXYZMngBarm FooXYZMngBarl600(FooXYZMngBard);

FooXYZMngBarm FooXYZMngBarl555(FooXYZMngBarl45 *FooXYZMngBarl170);

FooXYZMngBard FooXYZMngBarl581(FooXYZMngBarl45 *FooXYZMngBarl170);

FooXYZMngBarl104 *FooXYZMngBarl540(FooXYZMngBari FooXYZMngBarl45 *FooXYZMngBarl77, FooXYZMngBari FooXYZMngBarl164 *FooXYZMngBarl492, FooXYZMngBarl177 *FooXYZMngBarl187);

FooXYZMngBard FooXYZMngBarl520(FooXYZMngBari FooXYZMngBarl45 *FooXYZMngBarl77, FooXYZMngBarl104 *FooXYZMngBarl174);

FooXYZMngBarl105 *FooXYZMngBarl553(FooXYZMngBari FooXYZMngBarl45 *FooXYZMngBarl77, FooXYZMngBari FooXYZMngBarl178 *FooXYZMngBarl580, FooXYZMngBarl188 *FooXYZMngBarl187);

FooXYZMngBard FooXYZMngBarl562(FooXYZMngBari FooXYZMngBarl45 *FooXYZMngBarl77, FooXYZMngBarl105 *FooXYZMngBarl174);

[900ss (900ss)]

Detlef Kunz schrieb:
> Ich hatte eben Spaß :)
> Das sind offensichtlich Deklarationen von Funktionen und Strukturen.

Ich bin jetzt richtig beeindruckt was du alles kannst.

Ich schrieb schon:
> Möglichkeiten gibt es immer.

Selbstverständlich kann man das rekonstruieren. Und selbst dann bleibt 
es schwer. Es ist immer eine Frage des Aufwandes.

[Karl H. (kbuchegg)]

900ss D. schrieb:

> Selbstverständlich kann man das rekonstruieren. Und selbst dann bleibt
> es schwer. Es ist immer eine Frage des Aufwandes.

Wobei du zugeben musst, dass du dir auch ein schlechtes Beispiel 
ausgesucht hast. Das jemand Definitionen und Prototypen erkennt, da sag 
ich nur: 'gähn'.

Lass mal ein Stück Code, 1 Funktion so 200 bis 300 Zeilen, durch den 
Obfuscator laufen und dann schaun wir mal weiter, wie lange Detlef 
braucht, um rauszufinden, was der Code macht.
Dann da fängt Reverse Engeniering an. Wobei das noch die einfachere 
Stufe ist. Interessant wird es dann bei mehreren Funktionen, die auf 
einer gemeinsamen (internen) Datenstruktur operieren, deren Zweck man 
nicht kennt und deren Bedeutung von Strukturmember (beispielsweise), man 
dann auch erst mal erraten muss.
Da muss der Leidensdruck dann schon sehr hoch sein, wenn man sich dann 
auch noch die Rückübersetzung aus Object-Code davorsetzt. Wer das 
knackt, der hat es sich verdient.

[900ss (900ss)]

Karl Heinz schrieb:
> 900ss D. schrieb:
>
>> Selbstverständlich kann man das rekonstruieren. Und selbst dann bleibt
>> es schwer. Es ist immer eine Frage des Aufwandes.
>
> Wobei du zugeben musst, dass du dir auch ein schlechtes Beispiel
> ausgesucht hast. Das jemand Definitionen und Prototypen erkennt, da sag
> ich nur: 'gähn'.

Eben, ich war wirklich beeindruckt ;) Ich hab einfach wahllos in den 
Code gegriffen und es hier reingestellt. Was das war, habe ich vorher 
nicht geprüft. Es sollte nur zeigen, wie soetwas aussieht.

>
> Lass mal ein Stück Code, 1 Funktion so 200 bis 300 Zeilen, durch den
> Obfuscator laufen und dann schaun wir mal weiter, wie lange Detlef
> braucht, um rauszufinden, was der Code macht.
> Dann da fängt Reverse Engeniering an. Wobei das noch die einfachere
> Stufe ist. Interessant wird es dann bei mehreren Funktionen, die auf
> einer gemeinsamen (internen) Datenstruktur operieren, deren Zweck man
> nicht kennt und deren Bedeutung von Strukturmember (beispielsweise), man
> dann auch erst mal erraten muss.
> Da muss der Leidensdruck dann schon sehr hoch sein, wenn man sich dann
> auch noch die Rückübersetzung aus Object-Code davorsetzt. Wer das
> knackt, der hat es sich verdient.

Ich stimme dir vollkommn zu. Und ich schrieb auch schon, wer das 
entschlüsselt, der hat es sich verdient :)

[Rangi J. (rangi)]

Mich würde die Lösung von Dr.Sommer interessieren. Wie kann ich im 
Linkerscript reinschreiben, das eine Funktion eine bestimmte Adresse 
besitzt?
Im Detail würde ich meinen Code übersetzten, dann die Adressen der 
Übergabefunktionen aus dem map-File rausholen. Dann Name und Adresse in 
ein spezielles Linkerfile einbauen. Das geht dann zusammen mit dem 
zurecht geschnittenen hex-File und dem Header, in einer modifizierten 
Entwicklungsumgebung raus.
Nach dem Übersetzen und Linken werden das User-hex-File und mein 
existierendes hex-File zusammenkopiert. Danach kann man das System wie 
gewohnt flashen und debuggen.
Jetzt weiss ich nur nicht, wie das Linkerfile aussehen sollte. Kann mir 
da jmd helfen?

[MaWin (Gast)]

Rangi Jones schrieb:
> ich möchte meinen Quellcode gerne verstecken oder verschleiern.

Gib zu, dein Code ist dermassen Scheisse, daß du nicht willst, daß die 
Anderen sich darüber kaputtlachen.

[Rangi J. (rangi)]

g ja, das ausserdem

[Karl H. (kbuchegg)]

MaWin schrieb:
> Rangi Jones schrieb:
>> ich möchte meinen Quellcode gerne verstecken oder verschleiern.
>
> Gib zu, dein Code ist dermassen Scheisse, daß du nicht willst, daß die
> Anderen sich darüber kaputtlachen.

Im Eröffnungsposting steht, dass er Object-Code ausliefern will. D.h. 
den Quellcode kriegt sowieso keiner zu Gesicht.

@Rangi
Stell die Object-Files (-Os compiliert) in eine Library (eine echte 
Library, nicht das was hier oft als Lib bezeichnet wird), veröffentliche 
die Schnittstelle in Form von Header Files und gut ists.
Wenn dein Code nicht sowieso pipifax ist, ist das 'verschleiert genug', 
so dass die wenigsten dir da 'in die Karten schauen können'.

[Helmut L. (helmi1)]

Wenn ich deine Lib nutzen muesste und da waere ein Problem drin wuerdes 
du entweder hier antraben oder das Teil fliegt raus.

[klausr (Gast)]

Jasch schrieb:
> - Du hast einen Anwalt der einen ordentlichen Vertrag
> aufsetzt

> - die zahlen Dir genug Geld dass Du Dir keine Gedanken mehr um das ganze
> Problem machen musst -> kein Problem

Also, ich würde diese zwei Punkt kombinieren (+Supportvertrag) und denen 
gleich den Quelltext geben. Alles andere ist Blödsinn bzw. bringt dir 
nur zusätzliche Arbeit und denen einen erhöhten Aufwand. Wenn du gut 
bist, dann fragen sie bei Problemen in deinem Quelltext eh bei dir an. 
Wenn sie darauf nicht eingehen, würd ich gar nicht mit denen 
zusammenarbeiten.

[Mladen G. (mgira)]

Karl Heinz schrieb:
> Hab lange überlegt, ob ich diesen Gedanken aufgreifen soll. Denn dann
> kommen wieder die 'Ihr kennt mich doch gar nicht - wie könnt ihr so
> gemein sein' Vorwürfe.
>
> Genau so siehts aus.
> Wer in der Lage ist, Code zu schreiben, dessen Aufbau und Funktion
> komplex und interessant genug ist, dass sich jemand Unbefugter dafür
> interessiert, der weiß auch, wie er ihn ein bischen verschleiern kann,
> bzw. schon alleine dadurch, dass er eine saubere opaque Schnittstelle
> und Information Hiding betreibt, versteckt er die Details im Inneren des
> Codes, die der Applikationsprogrammierer nicht sehen soll bzw. sehen
> braucht.
>
> Und im Zweifelsfall ist es als Applikationsprogrammierer von Vorteil,
> sich die Internals ansehen zu können. Schon alleine aus dem Grund
> rausfinden zu können, warum das '*&%$§ wieder mal nicht funktioniert und
> was schief geht.

Eben, erlebe das meist nur bei "Anfaengern" seinen "kostbaren" Code 
verschleiern zu wollen, genau da ist es meist kontraproduktiv.

Wenn die eigene, ach so schuetzenswerte Arbeit dann noch die GNU 
Toolchain aufbaut wie GCC etc., wundere ich mich schon sehr wie man auf 
die Idee kommt das es gut waere zu verschleiern.

[Jasch (Gast)]

Rangi Jones schrieb:
> Im Detail würde ich meinen Code übersetzten, dann die Adressen der
> Übergabefunktionen aus dem map-File rausholen. Dann Name und Adresse in
> ein spezielles Linkerfile einbauen. Das geht dann zusammen mit dem
> zurecht geschnittenen hex-File und dem Header, in einer modifizierten
> Entwicklungsumgebung raus.

Modifizierte Entwicklungsumgebung?

Das meinst Du nicht ernst, wo willst Du denn einen Bekloppten finden der 
so einen Wahnsinn akzeptiert?

Ist das Motto dann "Du sollst keinen Fremdcode ausser meinem haben"? 
=8^(

[Jasch (Gast)]

klausr schrieb:
> Jasch schrieb:
>> - Du hast einen Anwalt der einen ordentlichen Vertrag
>> aufsetzt
>
>> - die zahlen Dir genug Geld dass Du Dir keine Gedanken mehr um das ganze
>> Problem machen musst -> kein Problem
>
> Also, ich würde diese zwei Punkt kombinieren (+Supportvertrag) und denen
> gleich den Quelltext geben. Alles andere ist Blödsinn bzw. bringt dir
> nur zusätzliche Arbeit und denen einen erhöhten Aufwand. Wenn du gut
> bist, dann fragen sie bei Problemen in deinem Quelltext eh bei dir an.

So kenne ich das auch, von der Seite aus die Code/Unterstützung bei 
anderen einkauft.

Der Code ist nicht halb so interessant wie die (kompetenten) Leute 
dahinter, die braucht man beim nächsten Projekt nämlich wieder. Und beim 
übernächsten...

[Peter D. (peda)]

Rangi Jones schrieb:
> Folgender Hintergrund: mein Quellcode soll Teil eines größeren Projektes
> werden, welches von anderen Leuten erzeugt wird.

Diese Leute sollte man besser nicht für dumm verkaufen.
Wenn davon wirklich ein Produkt abhängt, werden sie den Teufel tun und 
sich Daumenschrauben anlegen lassen.

Sie werden sich ganz einfach einen anderen Programmierer suchen, der zur 
Kooperation bereit ist.
Und der vor allem für den Fall des Ablebens/Geschäftsaufgabe usw. alle 
nötigen Unterlagen bereitstellt, das Projekt weiter führen zu können.

[Mark B. (markbrandis)]

Rangi Jones schrieb:
> ich möchte meinen Quellcode gerne verstecken oder verschleiern.

Eine wirklich seltsame Idee in einer Zeit, in der gute Entwickler immer 
mal wieder etwas von ihrem Code auf GitHub, Bitbucket, SourceForge etc. 
veröffentlichen. Oder auch hier im Forum.

Guter Sourcecode ist auch eine Form von Eigenwerbung.

[Mark B. (markbrandis)]

Ach ja, wer Quellcode verschleiern möchte, der ist hier goldrichtig:

http://www.ioccc.org/

Wobei man getrost davon ausgehen kann, dass die Leute deren Code dort 
veröffentlicht wurde es auch ordentlich können :)

[Karl H. (kbuchegg)]

Mark Brandis schrieb:
> Ach ja, wer Quellcode verschleiern möchte, der ist hier goldrichtig:
>
> http://www.ioccc.org/
>
> Wobei man getrost davon ausgehen kann, dass die Leute deren Code dort
> veröffentlicht wurde es auch ordentlich können :)

Und ganz wichtig: es zum Spass machen um zu zeigen was geht.

Ich bin jetzt zu faul, den entsprechenden Eintrag beim IOCCC 
herauszusuchen. Aber da gab es mal ein Programm, welches sich eigentlich 
ganz gut las und man sich fragte was dieser Eintrag beim IOCCC zu suchen 
hat.
Es stellte sich heraus, dass äussere Form und das was das Programm 
wirklich tat, nicht überein stimmte. Überflog man den Code, dann gewann 
man den Eindruck, dass es sich wohl um (ich glaube das war es) ein 
Sortierverfahren handelt. Tatsächlich war der Code aber ein 
Multiplexer/Demultiplexer und mit dem Präprozessor so verschleiert 
worden, dass man ohne tiefgreifende Analyse nicht erkennen konnte, worum 
es sich wirklich handelt. Das war für mich der Gipfel der Obfuscation 
und Irreführung.

[Mark B. (markbrandis)]

Ja, da gibt's echt viele gute Sachen beim IOCCC. Schachprogramme, 
Raytracer, ... ich staune immer wieder aufs Neue was die Jungs da so 
alles hinbekommen in dem bisschen Code.

[Detlef K. (adenin)]

Mark Brandis schrieb:
> Ach ja, wer Quellcode verschleiern möchte, der ist hier goldrichtig:
>
> http://www.ioccc.org/
>
> Wobei man getrost davon ausgehen kann, dass die Leute deren Code dort
> veröffentlicht wurde es auch ordentlich können :)

Wer macht mit, die wieder zu entschleiern? :)

Ich fang an: dlowe.c von 2013
Original:

main(a,b)char**b;{int c=1,d=c,e=a-d;for(;e;e--)_(e)<_(c)?c=e:_(e)>_(d)?d=e:7;
while(++e<a)printf("\xe2\x96%c",129+(**b=8*(_(e)-_(c))/(_(d)-_(c))));}

entschleiert:

main(argc, argv)
char**argv;
{
 int valuemin_idx = valuemax_idx = 1;
 int i = argc - 1;            //Anzahl der auszuwertenden Parameter

//alle Parameter von hinten durcharbeiten 
//wir suchen den Index des kleinsten und des größten Parameters
 for(;i ;i--)
  strtof(argv[i],0) < strtof(argv[valuemin_idx],0) ? valuemin_idx=i : strtof(argv[i],0) > strtof(argv[valuemax_idx],0) ? valuemax_idx=i : 7;
 
 
//alle Parameter von vorn durcharbeiten 
//die Parameterwerte werden skaliert und so als UFT-8 Code "e2 96 81" bis "e2 96 88" ausgegeben
 while(++i < argc)
  printf("\xe2\x96%c", 0x81 + (**argv = 8 * (strtof(argv[i],0) - strtof(argv[valuemin_idx],0)) / (strtof(argv[valuemax_idx],0) - strtof(argv[valuemin_idx],0))));
}

[Steffen R. (steffen_rose)]

Rangi Jones schrieb:
> Wie kann ich im
> Linkerscript reinschreiben, das eine Funktion eine bestimmte Adresse
> besitzt?

Kommt auf den Linker an.

[Steffen R. (steffen_rose)]

Helmut Lenzen schrieb:
> Wenn ich deine Lib nutzen muesste und da waere ein Problem drin wuerdes
> du entweder hier antraben oder das Teil fliegt raus.

Wenn das nur bei Open Source auch so wäre...

Das Argument, wenn ich es benötige soll ich mitarbeiten, wird immer 
wieder angebracht. Doch nicht jeder ist in der Lage in den Tiefen der 
KDE herumzuändern.

Insofern: Bei Problemen reicht es häufig nicht, den Sourcecode zu haben. 
Auch wenn unsere Kunden den Sourcecode haben muss ich trotzdem 
"antraben". Was auch Sinn macht.