Wie kann man in c einen Computer identifizieren.

lano

Mitglied
Moin.

Ich frage mich wie man in c einen computer identifizieren könnte.
Wenn ich zum Beispiel nur möchte das ein Programm nur auf einem Rechner läuft.
 

Mat

Mitglied
Was ist denn der Anwendungsfall?

Wenn ich zum Beispiel nur möchte das ein Programm nur auf einem Rechner läuft.
Das liest sich so, als würde das Programm auf mehreren Rechnern lokal herumliegen. Und da denke ich spontan an eine Dateiüberprüfung beim Programmstart. Und wenn die Datei nicht vorhanden ist, wird der Rest des Codes nicht ausgeführt.
 

Lowl3v3l

Mitglied
devCommunity-Experte
Wenn du einen Computer eindeutig identifizieren willst würde ich einfach die UUIDs aller Festplatten nehmen, das wird kaum jemand spoofen. Wenn du überprüfen willst ob ein Programm auf mehreren Rechnern läuft geht das mit asymmetrischer Kryptographie, da muss dann aber eine Chain-of-trust, ein zentraler Server oder fortgeschrittene schwarze Magie mit client-certificates hinter hängen.

Um ein XY-Problem zu vermeiden : was genau ist deine Absicht? Was willst du präzise tun?
 

rustyoldguy

Neues Mitglied
Hallo lano!

Eine interessante Aufgabenstellung, der ich vor einigen Jahren gegenüber stand. Damals fragte ich mich,
wie ich eine Software für bestimmte Benutzer, etwa Firmen sperren könnte, aber für andere Personen wie
Umschüler offen lassen könnte. Bei Firmen läuft die Kommunikation allermeistens über einen Server.
Größtenteils haben diese Windows als Betriebssystem. So wird oft ein Laufwerk (etwa "Z") als gemeinsame
Ablage benutzt. Darauf befinden sich ja gemeinsame Ordner.....

Ein Weg wäre, nach dem vorhanden sein dieses Laufwerks zu suchen und darauf Ordner mit einen
bestimmten Namen ausfindig zu machen, etwa welche mit dem Namen dieser Firma. Soll ja nicht so selten sein..
Bei vorhanden sein dieses Ordners das Programm sperren. Übrigens versuchte in meinem Fall der für die Firma
zuständige IT-Fachmann, einen parallelen Server auf FreeBSD-Basis zu installieren. Zwar gelang es ihm dies in den Grundzügen zu realisieren.

Aber auf Grund fehlender spezifischer Kenntnisse konnte er Programme, welche ich damals in
einen programmierer-forum (.....) hinein gestellt hatte, nicht ins System integrieren.
Vor seinem Versuch stellte ich gewisse Sachen fest, die ich hier nicht ausplaudern will, und wechselte die Programme
in diesem Forum von Windows auf Linux um, löschte meine von zu Hause mitgebrachte selbstgeschriebene Software.

Kleine Zusatzinfo als Anekdote:
Damals verdiente ich Netto 1425 Euro Festgehalt. Also nix mit Überstunden auszahlen lassen. Nach dem meine
Hand (staphylococcen) nicht mehr mit machte, bekam ich von der DRV damals 1245 Euro Übergangsgeld(auf die Kralle!).
Das liegt rein rechnerisch bei etwa 67 Prozent des Nettogehalts was mir theoretisch zugestanden hätte.
Dazu kommt das diese Firma 3 Monate den vollen Lohn durch die DRV bezahlt bekommen hatte.
Bei einigen Leuten Liegt die Zeit der Förderung je nach Krankheitsbild bei 1nem Jahr.

Germans Weg wäre sehr gut denkbar und ist der bessere. Etwa die Seriennummer der Festplatte.
Identifikation des Boards und des "BIOS".

Bei Anwendungen für libreoffice calc versuchte ich damals, die in BASIC-Dialekt geschriebenen Funktionen durch
JavaScript zu ersetzen. Letzteres ist mir aber bis heute nicht gelungen.

Heute bin ich gesundheitlich so weit wie damals(Diese Mist-Staphylococcus MRSE). Hab übrigens bald einige Termine deswegen. Bitte Daumen halten!
 

lano

Mitglied
Was ist denn der Anwendungsfall?
Einen konkreten fall gibt es so eigentlich nicht. Hab mich nur gefragt wie man das hinbekommen könnte.

Wenn du einen Computer eindeutig identifizieren willst würde ich einfach die UUIDs aller Festplatten nehmen
Das ist auch ne gute idee.

was genau ist deine Absicht? Was willst du präzise tun?
Eigentlich bin ich ja gegen einschränkungen. Aber jetzt hab ich mir nen program gebastelt was nach firmware suchen kann.
Jetzt ist die Freiheit das Problem. Denn man könnte locker 10.000 Anfragen abschicken. Und das wollte ich den Serverbetreibern nicht wirklich zumuten. So kam ich auf die Idee Limits einzuführen. Ich dachte daran das man einen Key mit angeben müsste um die Limits abzu schalten. Klar nix ist wirklich sicher. Aber ich würde auch mehr son script kiddy schutz brauchen. In der Hoffnung das die die das umgehen können nen bisschen ethik haben und die Server nicht zu tode ddossen :)

Ich wollt eigentlich ein zweites Programm nehmen das einen Keix generiert und dann einfach nen hash davon speichern.
Aber das war nur so schnell gedacht. So richtig hab ich mir da noch keine Gedanken gemacht.

Heute bin ich gesundheitlich so weit wie damals(Diese Mist-Staphylococcus MRSE). Hab übrigens bald einige Termine deswegen. Bitte Daumen halten!
Hättest du mich vor 25 Jahren gefragt was ich in 5 Jahren machen würde hätte ich dich ausgelacht. Daumen sind gedrückt.
 

Lowl3v3l

Mitglied
devCommunity-Experte
Wenn dein Ziel ist nicht den Server zu überlasten dann willst du das gar nicht aus C tun, sondern ne DoS-Mitigation benutzen( denn auch wenn key-checks fehlschlagen kann man damit immernoch nen DoS fahren), Cloudflare bietet sowas zum Beispiel an. Kann man auch selber über automatisierte Firewall-Regeln bauen, das wird dann aber schnell ziemlich hässlich und komplex.
 

lano

Mitglied
Cloudflare bietet sowas zum Beispiel an. Kann man auch selber über automatisierte Firewall-Regeln bauen, das wird dann aber schnell ziemlich hässlich und komplex.
Das sind nicht meine Server. Ich denke das die schon recht gut last aushalten. Aber man muss es ja nicht übertreiben. Ich sach mal so. Allein ~15 Millionen Geräte nutzen die Server jeden Tag. Das sind pi ma Daumen 75 Millionen anfragen am Tag. Da fallen einmalig 10.000 nicht ins gewicht. Wenn aber so ca 500 Program Nutzer noch alle 10 Sekunden 10.000 Anfragen senden läppert sich das halt.

Den Download Traffic ma gar nicht eingerechnet. Eigentlich sendet der Server zwei Zeiten zurück die das Programm dann warten sollte, halt ne zeit zwischen x und y sek. Aber die werte ich nicht aus.
 

rustyoldguy

Neues Mitglied
Einen konkreten fall gibt es so eigentlich nicht. Hab mich nur gefragt wie man das hinbekommen könnte.
Hab so was grad im Web gesehen:

C:
//#define _BSD_SOURCE   << is deprecated
#define _DEFAULT_SOURCE
#include <stdio.h>
#include <string.h>

#define DEVICE "sda"

int main(void) {
    char buf[1000];
    char hddname[300];
    strcpy(hddname, "udevadm info --query=all --name=/dev/sda | grep ID_SERIAL=");

  
    //FILE *f = popen("udevadm info --query=all --name=/dev/"
    //                DEVICE
    //                " | grep ID_SERIAL=", "r");
  
    FILE *f = popen(hddname, "r");
    fgets(buf, sizeof buf, f);
    pclose(f);

    buf[strcspn(buf, "\n")] = 0;
    printf("Seriennummer von device sda:\n%s\n", buf+13);

    return 0;
}
Hat seinen Vorteil wenn in Linux die Geräte als Dateien angesprochen werden.
 
Zuletzt bearbeitet von einem Moderator:

lano

Mitglied
Ja das hats... Wobei ich da glaub ich selber mit ioctr commands bei gehen würde. So schwer ist das gar nicht.
 

rustyoldguy

Neues Mitglied
Wenn man so was machen würde, wäre es möglicherweise ratsam, keine direkte Meldung raus zu geben, das das Programm
nicht auf diesen Rechner läuft, weil erkannt wurde, das jemand das Programm cracken wollte. Besser eine, die einen internen
Fehler in der Struktur des Programms vorgauckelt, etwa -inf oder bufferoverflow, Speicherabzug geschrieben, veraltete Version
einer DLL-Datei oder so etwas. Ein Hacker würde sofort bei einer direkten Benachrichtigung nach der Ursache forschen. Bis da
einer drauf kommt, das da keine Fehler vorliegen, hat der dann graue Haare.
 

rustyoldguy

Neues Mitglied
Kleiner Nachtrag:

Um den String zum Vergleich besser im Programm vor einem Hex-Editor zu verstecken, kann man
diesen in double-Variable verstecken:

C++:
#include <iostream>
#include <cmath>
#include <iomanip>

int Getvk(double wert)
{
 return (int)wert;   
}

double mul1k(double wert)
{
 return wert * 1000;   
}

void getletters(double wert[], char test[])
{
 int i, j, k;
 double nk, vk, dummya;
 
 k = 0;
 for(j = 0; j <= 3; j++)
  {
   nk = std::modf(wert[j], &vk);
 
 
   for(i = 0; i < 3; i++)
    {
     dummya = mul1k(nk);
     vk = Getvk(dummya);
    
     if(vk > 13)
      {
       test[k] = vk; 
       test[k + 1] = '\0';
       k++;
      }
    
    
    
     nk = std::modf(dummya, &vk);
    }
  
  }
}


int main(int argc, char **argv)
{
 double wert[4] ={12.072097108001,
                 28.108111032001,
                 33.087101108001,
                 33.116013000001};
 
 char test[50] = {0};
 
 getletters(wert, test);
 
 std::cout << "\nTeststring: " << test << std::endl<< std::endl;
 
 return 0;
}
Ausgabe hier:
Code:
Teststring: Hallo Welt
 

lano

Mitglied
Um den String zum Vergleich besser im Programm vor einem Hex-Editor zu verstecken, kann man
diesen in double-Variable verstecken:
Ach hör bloß auf. :LOL: An sowas hab ich auch schon gedacht. Ich war gedanklich schon bei verschlüsselung der strings und noch schlimmer.
Aber cool. Fehlt noch nen codierer und dann wäre das schon nen resourcen eintrag :rolleyes:
 

aligator

Neues Mitglied
Also ich halte das was du vor hast für eher sinnlos aus Sinnhaftigkeits-Perspektive.
Andererseits ist es durchaus eine interessante Fragestellung der man aus Neugier natürlich trotzdem nachgehen kann.

Deshalb ein paar Gedanken von mir dazu:

Für deinen Anwendungsfall bringt das wenn ich es richtig verstanden habe meiner Meinung nach nicht viel:
Ein Script Kiddy findet heut zu tage genügend Tools, deren Hauptfunktion das ddosen ist. Also glaube ich nicht dass diese dein Tool dafür nutzen würden. Und andererseits hat auch ein (wenig mehr fortgeschritteneres) Script Kiddy denke ich keine Probleme sich ein kleines Script zu schreiben, was dauerhaft Anfragen an den Server sendet. (Ein Script Kiddy das kein Script schreiben kann ist kein Script Kiddy...)

Aber als Maßnahme dagegen dürfte einfach eine simple Beschränkung ohne viel Schnickschnack reichen. Dies macht auf jeden Fall Sinn, allein schon um auch nicht aus versehen zu viele Anfragen zu senden. (Wobei ein gut eingestellter Server sowieso irgendwann nö sagt und einfach alles ignoriert.)

Sobald es in Richtung professionellen Cracker geht: Die gehen normal auf Programme die verkauft werden können und nicht auf tools, die man vielleicht als ddos tool umfunktionieren könnte. Fällt somit eigentlich auch aus deiner Zielgruppe raus.

Das was hier bisher vorgeschlagen wurde geht finde ich stark schon in Richtung Lizensierung (was in die zweite Zielgruppe fallen würde), was aber
1. ein anderer Anwendungsfall ist (da du ja eigentlich nur Script Kiddys abschrecken willst)
2. ein eher schwieriges Thema ist (nicht umsonnst gibt es eine lange historie an bereits gecrackten Programmen)

Da ich zwar grundsätzlich Lizensierungen hasse, aber die technische Seite davon durchaus interessant finde hier ein paar Dinge dazu:
Was für Möglichkeiten gibt es (teils nat. auch in Kombination):
1. ein versteckter Algorithmus der z.B. einen Lizenzschlüssel verifiziert:
Diese Methode wurde vor allem früher verwendet, speziell als es noch kein Internet gab. Für neuere Programme wird das denke ich immer seltener.

Da ich mich mal ein bisschen für Hacking-Challenges (Sehr zu empfehlen, man lernt wirklich viel über die internen Funktionen von Programmen und anderen IT-Themen. z.B. https://www.root-me.org/?lang=de aber bitte nur zu reseach zwecken) interessiert habe, bin ich dadurch auch auf das Cracken gestoßen. Dadurch kann man einen super Einblick bekommen, wie sowas denn eigentlich funktioniert:

Wie läuft das grob ab? Man guggt sich den assembler-code an und sucht eine Stelle, die den Lizenzschlüssel verifiziert. In vielen Fällen findet man den Code in dem man nach einem String sucht, der z.B. in dem Eingabefenster für den Lizenzschlüssel steht.
Hat man die Stelle gefunden gibt es zwei möglichkeiten. Entweder man versucht den Algorithmus zu reverse engineeren und dann mit diesem einfach passende Keys zu generieren oder man schaltet einfach den entsprechenden check aus.

Oft ist dieser Check irgend ein If (if keyValide(key) {...) und genau das ist sehr easy zu umgehen. Oft reicht es dann ein Bit zu ändern um zum Beispiel von einem jump befehl einen nicht-jump befehl oder aus einem jump befehl einen NOP (no operation) befehl zu machen.

Es gibt hier bestimmt noch viele andere möglichkeiten, aber ich bin da auch kein Experte.


Warum ist diese Methode schlecht?
ganz einfach, dieses Methode basiert hauptsächlich auf "security by obscurity" was wahrlich einfach immer umgehbar ist, mit mehr oder weniger Aufwand.
Also egal wie speziell du dir da einen Algorythmus ausdenkst es gibt immer die Möglichkeit sich das Assembler anzuguggen. Ja es kann durchaus schwer sein, aber es ist per Definition nie unmöglich. Darunter fällt auch die Idee von @rustyoldguy mit dem zerlegen vom String in double-werte. (Was ich durchaus ne interessante Idee finde, wär ich jetz nicht gleich drauf gekommen :))

2. Verifikation anhand der Hardware:
Also das was wohl dein erster Gedanke war. Hierzu eine kleine Anekdote:
Ich habe mal ein bisschen mit FPGAs gespielt (auch eine sehr interessante sache. Ich hab da z.B. ein VGA Signal mit generiert).
Nun ist es so dass ich da natürlich eine Software gebraucht habe, die idiotischerweise einen Key gebraucht hat. (Warum idiotischerweise? weil es trotzdem kostenlos war und man jederzeit einen neuen key auf der Webseite bekommen kann)

Nun ist es da so, dass man hierzu auf deren Webseite die MAC-Adresse des eigenen PCs eingeben muss um einen Key zu erhalten.
Soweit so gut.

Problem war nur, dass ich ein durchaus modernes Linux verwende und außerdem WLAN. Was macht dieses doofe Programm:
Es guggt natürlich NUR die netzwerkkarte namens eth0 an und nichts anderes.

Das ist deshalb problematisch, da bei vielen aktuellen Distributionen eth0 gar nicht mehr existiert. (https://www.freedesktop.org/wiki/Software/systemd/PredictableNetworkInterfaceNames/) Stadtessen schauen die jetzt so aus: enp5s0f2
Und da ich ja wlan verwendet hab, hätte es so oder so nicht mit der Wlan MAC funktioniert sondern immer nur mit der von der LAN-Karte. Was also wenn man an dem PC gar kein LAN hat?

Lösung:
zum Glück ist es auf Linux ein leichtes sich eine neue, virtuelle Netzwerkkarte mit beliebigem Namen zu erstellen.
Also hab ich eine virtuelle Karte mit dem Namen eth0 und einer beliebigen MAC erstellt und diese MAC Adresse dann auf der Webseite eingetragen.


Warum ist diese Methode schlecht?
Weil Hardware niemals die Eigenschaften hat dass sie
1. wirklich gleich bleibt
2. nicht spoof-bar ist
3. sich vielleicht technisch was ändert, so dass es vlt irgendwann eine ID gar nicht mehr gibt oder diese irgendwann anders heisst.

Somit halte ich auch die Idee mit den UUIDs der Festplatten für eher sinnlos.
1. kann man die einfach ändern
2. wirst du damit die Benutzer deines Programmes nur ärgern, weil immer wenn die irgendwas am System ändern, gehts nicht mehr... (ja bei mir ändert sich dauernd irgendwas)
3. das kann auch sehr betriebssystemspezifisch sein mit
Code:
udevadm info --query=all --name=/dev/sda | grep ID_SERIAL=
kommst du auf Windows nicht weit. Die Portabilität aufs Spiel zu setzen gegen ein bisschen anti-skript-kiddy wärs mir nicht wert.

Ich persönlich würde mir den sowieso entweder nen Workaround bauen (wie z.B. mit der virtuellen Netzwerkkarte) oder auf ein anderes Programm umsteigen.

3. Per Internet authentifizieren oder gleich eine Web-App
Hier hab ich leider keine Geschichte zu erzählen, aber auch per Internet authentifizieren könnte evtl. leicht umgangen werden entweder indem man einen Server fälscht und die Domain umleitet auf einen eigenen fake-server oder weil man wie im Punkt 1 beschrieben irgendwo im Assembler ein bisschen rumpfuscht um den check auszuschalten.

Die einzige Möglichkeit die wirklich zu 100% funktionieren würde, wäre eine Web-App zu erstellen denn dann hat keiner eine Möglichkeit am code rumzufuschen.
Problem hierbei: In deinem Fall verlagerst du dann nur das Problem, weil jetzt kann man deinen Server einfach ddosen :)

Es gibt garantiert noch weitere Möglichkeiten, die vlt. sogar mit irgendwelchen kryptografischen signaturen und selbst-integrität-checks, etc funktionieren.
Über dieses Problem haben sich ja schon sehr viele schlau Leute den Kopf zerbrochen und (wenn man sich die Menge der bereits gecrackten Programme anguggt) sind oft auch daran gescheitert.

Ich finde nichts davon ist wirklich der Aufwand wert erst recht nicht wenns nur um Script Kiddys geht, es sei den man hat spaß daran sowas zu bauen :)

So viel dazu von mir und viel Spaß beim weiteren basteln.
 

rustyoldguy

Neues Mitglied
Hallo lano!

Hab hier mal ein wenig gebastelt um einen Passwortschutz da mit rein zu bringen.
Ein Beispiel für die farbliche Ausgabe in Linux-Terminals über ANSI.

Sonst mal ein wenig rein gucken.
C:
#ifndef WISCOD_INC_

#define WISCOD_INC_



#include <iostream>

#include <iomanip>

#include <string.h>

#include <stdlib.h> //EXIT_SUCCESS

#include <cmath>



#define BLUE "\033[0;34m"

#define SCHWARZ "\x1b[30m"

#define RED     "\x1b[31m"

#define LIGHT_GRAY "\x1b[0;37m"

#define WEISS "\x1b[1;37m"

#define OLDCOLOR "\e[0m"

/*

#define ANSI_COLOR_RED     "\x1b[31m"

#define ANSI_COLOR_GREEN   "\x1b[32m"

#define ANSI_COLOR_YELLOW  "\x1b[33m"

#define ANSI_COLOR_BLUE    "\x1b[34m"

#define ANSI_COLOR_MAGENTA "\x1b[35m"

#define ANSI_COLOR_CYAN    "\x1b[36m"

#define ANSI_COLOR_RESET   "\x1b[0m"

*/



void chartostr(int zahl, char puffer[]);

int Getvk(double wert);

double mul1k(double wert);

void getletters(double wert[], char test[], int werte, char Passwort[]);

void ConvertStringToDoubleArray(char hddnum[], double (*x)[10], char Passwort[]);

void ShowDoubleArray(double a[]);



#endif
zuerst der header wiscod.h:


Dann die dazugehörige wiscod.cpp:
C:
#include "wiscod.h"

// Wandelt einen char-Wert in einen String MIT Vornullen um. Vornullen sind Wichtig zur double-Wert-Bildung.
// arbeitet von 0 bis 999 dezimal
void chartostr(int zahl, char puffer[])
{
  int slei = 0, produkt = 0, dummy = 0, sleib = 0;
  int testzahl[3] = {1, 10, 100};
  char zahlsymbole[10] = {'0','1','2','3','4','5','6','7','8','9'};

  sleib = 0;
  // Wenn Zahl Null ist
    if (zahl == 0 )
     {
      puffer[0] = '0';
      puffer[1] = '0';
      puffer[2] = '0';
      puffer[3] = '\0';
     }
     else
   for (slei = 2; slei >= 0; slei--)
     {
      produkt = testzahl[slei];  // 10^0 = 1, 10^=10 10^2 = 100
      dummy   = zahl / produkt;
      zahl   -= dummy * produkt;

      puffer[sleib++] = zahlsymbole[dummy];

      puffer[sleib] = '\0';
     }

}


// holt Vorkommananteil einer double-Variable als int-Wert
int Getvk(double wert)
{
int rewer = (int)wert;

return rewer;
}

// Noetig um 3-stellige Dezimalwerte zu gewinnen
// durch die Multiplikation wird der am Dezimalpunkt naechstgelegene Wert zum Integer-Wert
double mul1k(double wert)
{

return wert * 1000;
}

// Formt aus einem Array von double-Werten einen String aus ASCII-Werten
// arg1= Array mit double Werten zur Codierung
// arg2= StringArray fuer die aus den double-Werten gewonnenen chars
// arg3= Groesse des Double-Arrays
// arg4= Passwort zur Decodierung
void getletters(double wert[], char test[], int werte, char Passwort[])
{
int i, j, k, l, vorkomma, p, decodiert;
double nk, vk, dummya;
int pawolen = strlen(Passwort);

k = l = 0;
for(j = 0; j < werte; j++)
  {
   //std::cout << "double=" << std::setprecision(12) << wert[j] << std::endl;
    nk = std::modf(wert[j], &vk);


   for(i = 0; i < 3; i++)
    {
     dummya = mul1k(nk);
     //std::cout << "dummya = " << dummya <<  std::endl;
     vorkomma = Getvk(dummya);

     if(vorkomma > 13)
      {
       // /** Kuenftiger Block fuer Passwortschutz
 
      p = Passwort[l++];
      decodiert = vorkomma - p;
      if (l >= pawolen) l = 0;
 
      // * */
     
       //printf("k = %d    vorkomma=%d\n", k, vorkomma);
       test[k] = decodiert;
       //test[k] = vorkomma;
       test[k + 1] = '\0';
       k++;
      }
     
     nk = std::modf(dummya, &vk);
    }

  }
}

void ConvertStringToDoubleArray(char hddnum[], double (*x)[10], char Passwort[])
{
int i, j, k = 0, l = 0, p = 0, numlen = -1;
int codiert;
char chnum[10] = {0};      // String für die einzelnen dezimal-Werte, 3 Stellen (eventuell mit Vornullen) noetig
char dchar[30] = {0};      // Hier wird der String erzeugt aus dem dann der double-Wert gebildet wird
char *stopzfolge; // wegen strtod
numlen = strlen(hddnum);
int pawolen = strlen(Passwort);

for (i = 0; i < numlen; i+= 3)
{
   printf("-------------------------\n");
   for (j = i; j < i + 3; j++)
    {
      ///** Kuenftiger Block fuer Passwortschutz
 
       p = Passwort[l++];
 
       codiert = p + hddnum[j];
      //printf("p= %3d %c \n", p, p);
 
      if (l >= pawolen) l = 0;
 
      chartostr(codiert, chnum);  // Wandelt einzelne ASCII-Buchstaben von hddnum in dreistellige Strings um  
   
       // * */
   
      //chartostr(hddnum[j], chnum);  // Wandelt einzelne ASCII-Buchstaben von hddnum in dreistellige Strings um
     
     if (j == i){ strcpy(dchar, "0."); strcat(dchar, chnum); }
      else if(j > i) strcat(dchar, chnum);
      if (j == (i + 2)) strcat(dchar, "33"); // Ist notwendig, sonst kann es bei der letzten Zahl zu Rundungsfehlern kommen und dann falscher String
     printf("j=%2d  %schar:%c  %s dec as a string: %s%s  current dchar:%s\n", j, BLUE, hddnum[j], RED, chnum,OLDCOLOR, dchar);
     if(j == (i + 2))
      {
       (*x)[k++] = strtod(dchar, &stopzfolge);
      }
    }
}


}

// hier wird das Array mit den double-Werten gezeigt
void ShowDoubleArray(double x[])
{
  for (int i = 0; i < 10; i++)
    printf("j=%2d  x=%.12lf\n", i, x[i]);
}
Nun main.cpp:

C:
/** Wandelt String in ein Array von double-Werten um und wieder zurueck */

#include "wiscod.h"


int main(int argc, char **argv)
{
char hddnum[300] = {0};    // String für die Speicherung der hdd-Seriennummer
char Passwort[100] = {0};
char Passwortb[100] = {0};
double x[10] = {0};        // hier werden die double-Werte abgelegt
char test[50] = {0};       // Der String, der aus den double-Werten gebildet wird
int numlen = -1;           // Laenge des Strings der hdd-Seriennummer
int erge = -1;


strcpy(hddnum,"ST2014DM006-4DM168_Z7ZBKR9L");
numlen = strlen(hddnum);
strcpy(Passwort, "PierreAccoce");

// Nur fuer Testzwecke der Codierung
/*
Passwort[0] = 1;
Passwort[1] = 1;
Passwort[2] = 1; Program exited with return code: 0

Passwort[3] = 1;
Passwort[4] = 1;
Passwort[5] = '\0';
*/
printf("Zu codierende Seriennummer:\n%s\n", hddnum);

printf("Laenge der Nummer in Byte: %d Byte\n", numlen);
ConvertStringToDoubleArray(hddnum, &x, Passwort);

printf("-------------------------\n");

ShowDoubleArray(x);

printf("-------------------------\n");

// Zu Testzwecken:
// Wird das falsche Kennwort verwendet, kommt ein fehlerhafter String
printf("Bitte Passwort eingeben: ");
scanf("%90s", Passwortb);
//strcpy(Passwort, "PeterLustig");


  // Formt aus den double-Array das String zum Vergleich
getletters(x, test, 10, Passwortb);

printf("\nTeststring: %s\n", test);

  // Vergleich ob Stings gleich
erge = strcmp(hddnum, test);
printf("Vergleich der Strings: %d\n", erge);

if (erge)
  {
   printf("Error in Runtime Libary. Speicherabzug geschrieben.\n");
   return 0;
  }
   else
    printf("Programm erfolgreich beendet\n");
 

return EXIT_SUCCESS;
}
Ich denke, das hier ist eine Art Machbarkeitsstudie.
Ich wäre damals besser dran gewesen, wenn ich meinen eigenen Laptop statt den Firmeneigenen Rechner zu benutzen
und hätte damals solche Möglichkeiten gehabt wie heute. Das muss jeder selber wissen. Ein gewisser Schutz sollte schon sein.

Eigentlich ist das Benutzen von Linux aufm Desktop alleine schon ein gewisser Kopierschutz. Von FreeBSD ganz zu schweigen.

Brauchbar wäre das in codierter Form als Nachweis des Urheberrechts. Bei Berechnungen könnte ich mir vorstellen,
das Programm so zu gestalten, das wesentliche Teile des double-Arrays in die Berechnung mit einfließen und so
einen Schutz der Manipulierung des Urhebernachweises durch Abänderung der Werte im Array bieten.
Gewiss, knacken kann man alles, fragt sich nur, was dabei raus kommt.

Ein Beispiel aus dem Maschinenbau:

Eine Firma für Sondermaschinen baute in wesentliche Teile einer Ihrer Maschinen eine Welle mit dem Maß
11,11h7 und Bohrung 11,11H7 ein. Beide mit 18µm Toleranz versehen.
Wenn Leute mit modernen 3D-Scannern die Teile kopieren, so Arbeiten diese etwa mit +-20µm Toleranz bei
der Erfassung der Maße. Also 40µm insgesamt. Somit bei rund 0,08mm für beide Teile.
Somit müssten die Kopisten einen eigenen Ingenieur damit beauftragen und der Kostenvorteil durch das Kopieren ist dahin.

Ein
Zehntel mm ist im Maschinenbau wie ein Meter für einen Maurer!
Am Ende sitzen jedoch immer Menschen, welche alles in die Praxis umsetzen. So kann man bei diesem
Beispiel mit an Sicherheit grenzender Wahrscheinlichkeit davon ausgehen, das diese Teile als Allgemeintoleranzen
angesehen werden, wo doch eine präzise Tolerierung von Nöten ist.

Zudem liegt bei einer solchen Manipulation der schwarze Peter bei dem der das Programm gecrackt hat.
Wer ein solches Programm ändert, kann sich bei fehlerhaften Berechnungen nicht auf den ursprünglichen Autor berufen.
Solche Sachen können gaaanz schön teuer werden. Nehmen wir einmal an, ich hätte vor meiner Entlassung ein solches Gimik
in meine Software zur Berechnung von Passungen bei Maschinenbauteilen eingebaut, welche nur falsche Werte liefert, wenn
diese sagen wir mal, "unrechtmäßig" genutzt wird, gibt aber sonst keinen Mucks von sich.
Was könnte ich dafür, wenn die mir mein Programm ohne mein Wissen von meinem Stick geklaut hätten??
Das gilt im Maschinenbau wie bei der Software.
 
Zuletzt bearbeitet:

lano

Mitglied
welche nur falsche Werte liefert, wenn
diese sagen wir mal, "unrechtmäßig" genutzt wird, gibt aber sonst keinen Mucks von sich.
Was könnte ich dafür, wenn die mir mein Programm ohne mein Wissen von meinem Stick geklaut hätten??
Das gilt im Maschinenbau wie bei der Software.
Intresannter ansatz.
 

rustyoldguy

Neues Mitglied
Wenn die Software keinen Mucks von sich gibt, meine ich, das diese scheinbar ohne Probleme weiter läuft, aber
ohne Vorwarnung fehlerhafte Werte von sich gibt, weil die double-Arrays zur String-Gewinnung manipuliert wurde.
Somit kommt ja ein Hacker weit aus seltener auf die Idee, das er da was falsch gemacht hat. Deswegen sollte man
wenn es geht immer zwei Sticks haben, die völlig gleich aussehen, aber einen anderen Inhalt haben. den präparierten
kannst du ohne Probleme in deiner Brotzeittasche lassen, den anderen behältst du lieber bei dir, ohne das einer das merkt.
Diese Leute können sich nicht zuerst darauf berufen, die Software legal erworben zu habe, um später bei Fehlern diesen
auf dem jenen zu schieben, von dem die Software geklaut wurde. Selber schuld.

Übrigens:
Grundsätzlich sollte man als Praktikant oder Umschüler äußerst vorsichtig sein mit mitgebrachten Dokumenten oder
selbstgeschriebener Software. Bei mir war das so, das ich gelernter Dreher bin (Gesellenpüfung Juni 1983), IHK-geprüfter Qualitätsfachmann für Längenprüftechnik, geprüfter DGQ-Qualitätsassistent und DGQ-Qualitätsfachkraft, habe Schulungen in Prüfmittelmanagement und Überprüfung von Messmitteln wie Grenzlehrdornen oder Messuhren gemacht und noch einiges anderes.
Dieses Jahr am 1ten September werden es 40 Jahre, wo ich im Berufsleben stehe(Lehrbeginn 01.09.1980).
Viele Firmen haben Praktikanten und Co. fest eingeplant. Das liegt daran, das Qualitätssicherung einer der teuersten Posten
überhaupt bei Firmen ist. Laut Gesetz (SGB) kann ein Umschüler ein viertel Jahr oder länger dadurch gefördert werden,
das man ihm in diesem Zeitraum komplett den Lohn zahlt. Das heißt, der Arbeitgeber bekommt den vollen Lohn vom
Kostenträger, etwa Arbeitsamt, Berufsgenossenschaft oder DRV. Dafür muss er aber diesen mindestens genau so lange
weiter beschäftigen, wie er den Lohn vom Kostenträger gekriegt hat, sonst muss er die Förderung zurück zahlen.
Dazu gilt, das ab einer Beschäftigungsdauer von 9 Monaten dieser den Anspruch auf dem selben Lohn hat, wie seine
fest angestellten Kollegen.

Das ist genau der Grund, warum viele (etwa 67 Prozent) vor diesem Zeitraum entlassen werden. Laut Gesetz hat man aber
nur bei einer durchgehenden Beschäftigungsdauer von 12 Monaten ein Recht auf ALG I.

Wenn man jetzt böse Gedanken hätte(!!!) könnte man meinen, das wäre Absicht der Regierung, um die Leute in Harz IV zu
bringen und von ALG 1 abzuhalten um Kosten zu sparen.

Aber zurück dazu warum man vorsichtig sein sollte. Wenn ein Betrieb nach der DIN ISO 9000er Reihe Zertifiziert ist, muss
er das regelmäßig vorweisen, etwa alle 2 Jahre oder alle Jahre. Dazu muss er beim Audit ALLE Prüf- und Messmittel
vorher überprüft haben lassen! Das ist sehr teuer. Deshalb versucht man oft Leute nicht sehr lange auf solchen Posten
zu lassen. Früher oder später merken diese, das Sie vera****t werden und gehen auf die Barrikaden..

Rechtlich gesehen müssten alle, welche entlassen werden, laut Gesetz (Copyright) ihre mit gebrachten Unterlagen und
andere Dokumente wieder einsammeln. Kein Scherz! Falls Ihr aber die Software auf dem Firmenrechner geschrieben habt,
dann gehört diese der Firma. Also besser Software verwenden, die Ihr VOR eurer Einstellung schon fertig hattet. Finger weg
davon, diese dann in der Firma zu verbessern oder anzupassen! Lass auch gefälligst eure Software auf eurem Rechner!
Besser für euch! Wenn der dann schnell genug ist und Ihr einen Emulator drauf habt, lasst die Software auf dem Emulator
laufen. Selbst dann, wenn der Laptop auch nur für kurze Zeit durch einen anderen bedient wird, so wird es sehr schwer sein,
die Software zu "besorgen".

Deshalb ja auch meine Meinung, solche Betriebssysteme wie OpenBSD, FreeBSD und Linux sind besser, da die meisten
Firmen ja Windows als Betriebssystem haben und bei einer Umstellung auf Unix-Derivate die Kosten und Probleme bei
der Übertragung der Datensätze viel zu hoch wären. Da aber in jüngster Zeit den Leuten von Fensterli anscheinend die
Entwickler abhanden kommen, sind diese gezwungen, Linux-Software zu integrieren oder zuzulassen.
Aber selbst dann, lässt sich eine solche Softwarelösung wie hier dargestellt, sich nicht durch einige Handgriffe mit
den Hexeditor anpassen. Meine Idee mit dem Gimick könnte solche (Schmarotzer-)Firmen dazu bringen, von so
etwas besser die Finger zu lassen.
Hand aufs Herz, welche Firma hat einen Windowsserver und einen Linuxserver parrallel zueinander, beide integriert?

So gesehen bietet Linux von vorn herein einen Kopierschutz. Selbst dann, wenn die Firma die Original-Source in
die Finger bekommt, müssten diese die Software an Windows anpassen, was wiederum Kosten verursacht.
Es geht nicht darum, Besitz zu wahren, sondern zu verhindern das andere Mist machen und dann wird euch alles
in die Schuhe geschoben! Deshalb solche Vorsichtsmaßnahmen.

Zudem ist es doch recht seltsam, wenn etwa eine Firma mit einem Jahresumsatz von mindestens 150 Millionen Euro
etwa Messmittel und Prüfmittel aus der Liste kurz vor dem Audit raus nimmt um den Auditor zu täuschen um Kosten
bei der Überprüfung zu sparen und dazu Software vom Praktkanten oder Umschüler (mopst?) besorgt.

Ein charakterliches Armutszeugnis der besonderen Güte ist wohl dies.

Wie sagt man bei uns in Bayern:
Nix fur unguat!
 
Zuletzt bearbeitet:
Oben Unten