Follow along with the video below to see how to install our site as a web app on your home screen.
Anmerkung: This feature may not be available in some browsers.
und mit plattform- / compilerspezifischem Code versuchen deren ID zu lesen.
Wenn ich zum Beispiel nur möchte das ein Programm nur auf einem Rechner läuft.
Was ist denn der Anwendungsfall?
Wenn du einen Computer eindeutig identifizieren willst würde ich einfach die UUIDs aller Festplatten nehmen
was genau ist deine Absicht? Was willst du präzise tun?
Heute bin ich gesundheitlich so weit wie damals(Diese Mist-Staphylococcus MRSE). Hab übrigens bald einige Termine deswegen. Bitte Daumen halten!
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.
Da gibts doch was von ... Google:Klingt nach ner Aufgabe für dich
Einen konkreten fall gibt es so eigentlich nicht. Hab mich nur gefragt wie man das hinbekommen könnte.
//#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;
}
#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;
}
Teststring: Hallo Welt
Um den String zum Vergleich besser im Programm vor einem Hex-Editor zu verstecken, kann man
diesen in double-Variable verstecken:
udevadm info --query=all --name=/dev/sda | grep ID_SERIAL=
#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
#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]);
}
/** 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;
}
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.