Skip to content
Snippets Groups Projects
Commit ba543163 authored by Peter Gerwinski's avatar Peter Gerwinski
Browse files

Notizen und Beispiele 8.7.2024

parent 1f72c158
No related branches found
No related tags found
No related merge requests found
...@@ -515,6 +515,7 @@ Algorithmus: ...@@ -515,6 +515,7 @@ Algorithmus:
- Problem: Woran erkenne ich, welche Chain vertrauenswürdig ist? - Problem: Woran erkenne ich, welche Chain vertrauenswürdig ist?
Beim Proof of Work erkenne ich es an der höchsten Schwierigkeitsstufe. Beim Proof of Work erkenne ich es an der höchsten Schwierigkeitsstufe.
Beim Proof of Stake ist genau diese Kontrolle nicht möglich. Beim Proof of Stake ist genau diese Kontrolle nicht möglich.
https://medium.com/@dsl_uiuc/fake-stake-attacks-on-chain-based-proof-of-stake-cryptocurrencies-b8b05723f806
Beispiel: Beispiel:
- Ethereum hat am 1.12.2020 damit angefangen, von Proof of Work auf Proof of Stake - Ethereum hat am 1.12.2020 damit angefangen, von Proof of Work auf Proof of Stake
...@@ -619,3 +620,11 @@ Kartensysteme: Debit- und Kredit-Karten, Lastschrift per Karte ...@@ -619,3 +620,11 @@ Kartensysteme: Debit- und Kredit-Karten, Lastschrift per Karte
Mögliches System, das die Anonymität von Bargeld mit den Vorteilen der Mögliches System, das die Anonymität von Bargeld mit den Vorteilen der
Kartensysteme vereinigt: GNU Taler Kartensysteme vereinigt: GNU Taler
@-Symbol in URLs, 08.07.2024, 18:04:30
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Echte URL: https://medium.com/@dsl_uiuc/fake-stake-attacks-on-chain-based-proof-of-stake-cryptocurrencies-b8b05723f806
~~~~~~~~~~Rechner
Falsche URL: https://medium.com:42@192.168.0.1/@dsl_uiuc/fake-stake-attacks-on-chain-based-proof-of-stake-cryptocurrencies-b8b05723f806
Benutzername~~~~~~~~~~ ~~ ~~~~~~~~~~~Rechner
Passwort
#include <stdio.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
int main(void){
pid_t pids[10]; // Platz für 10 Prozess-IDs (die Kindprozesse)
int i; // Laufvariable
for (i = 0; i < 10; ++i) {
// Der Vaterprozess erzeugt nun einen Kindprozess,
// welcher unabhängig vom Vaterprozess mit der
// erneuten Ausführung des Programms beginnt.
// Ein Kindprozess erzeugt keinen Fork von sich selbst.
pids[i] = fork();
if (pids[i] == 0) {
// dann befinden wir uns in einem der 10 Kindprozesse
// Der erste Kindprozess wartet 10 Sekunden und jeder
// weitere Kindprozess wartet 1 Sekunde kürzer als der
// vorige.
sleep(10-i);
printf ("%d BRAINS! ", i);
fflush(stdout);
exit(0); // Kindprozess erfolgreich beenden
}
}
//
// hier kommt nur der Vaterprozess vorbei
for (i = 0; i < 10; ++i){
// Der Vaterprozess wartet nun, bis der Reihe nach jeder
// seiner 10 Kindprozesse beendet ist. Leider wird auf das
// Kind mit der längsten Wartezeit zuerst gewartet. Obwohl
// die anderen Kinder längst erfolgreich beendet wurden,
// blockiert das erste Kind eine Bereinigung der Prozesstabelle
printf("%d ", pids[i]);
fflush(stdout);
waitpid(pids[i], NULL, 0);
}
printf("\n");
//
// while (1);
return 0; // Vaterprozess erfolgreich beenden
}
#include <stdio.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
int main(void){
pid_t pids[10]; // Platz für 10 Prozess-IDs (die Kindprozesse)
int i; // Laufvariable
for (i = 0; i < 10; ++i) {
// Der Vaterprozess erzeugt nun einen Kindprozess,
// welcher unabhängig vom Vaterprozess mit der
// erneuten Ausführung des Programms beginnt.
// Ein Kindprozess erzeugt keinen Fork von sich selbst.
pids[i] = fork();
if (pids[i] == 0) {
// dann befinden wir uns in einem der 10 Kindprozesse
// Der erste Kindprozess wartet 10 Sekunden und jeder
// weitere Kindprozess wartet 1 Sekunde kürzer als der
// vorige.
sleep(10-i);
printf ("%d BRAINS! ", i);
fflush(stdout);
exit(0); // Kindprozess erfolgreich beenden
}
}
//
// hier kommt nur der Vaterprozess vorbei
for (i = 0; i < 10; ++i){
// Der Vaterprozess wartet nun, bis der Reihe nach jeder
// seiner 10 Kindprozesse beendet ist. Leider wird auf das
// Kind mit der längsten Wartezeit zuerst gewartet. Obwohl
// die anderen Kinder längst erfolgreich beendet wurden,
// blockiert das erste Kind eine Bereinigung der Prozesstabelle
printf("%d ", pids[i]);
fflush(stdout);
waitpid(pids[i], NULL, 0);
}
printf("\n");
//
while (1);
return 0; // Vaterprozess erfolgreich beenden
}
#include <stdio.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
int main(void){
pid_t pids[10]; // Platz für 10 Prozess-IDs (die Kindprozesse)
int i; // Laufvariable
for (i = 0; i < 10; ++i) {
// Der Vaterprozess erzeugt nun einen Kindprozess,
// welcher unabhängig vom Vaterprozess mit der
// erneuten Ausführung des Programms beginnt.
// Ein Kindprozess erzeugt keinen Fork von sich selbst.
pids[i] = fork();
if (pids[i] == 0) {
// dann befinden wir uns in einem der 10 Kindprozesse
// Der erste Kindprozess wartet 10 Sekunden und jeder
// weitere Kindprozess wartet 1 Sekunde kürzer als der
// vorige.
sleep(10-i);
printf ("%d BRAINS! ", i);
fflush(stdout);
exit(0); // Kindprozess erfolgreich beenden
}
}
//
while (1);
// hier kommt nur der Vaterprozess vorbei
for (i = 0; i < 10; ++i){
// Der Vaterprozess wartet nun, bis der Reihe nach jeder
// seiner 10 Kindprozesse beendet ist. Leider wird auf das
// Kind mit der längsten Wartezeit zuerst gewartet. Obwohl
// die anderen Kinder längst erfolgreich beendet wurden,
// blockiert das erste Kind eine Bereinigung der Prozesstabelle
printf("%d ", pids[i]);
fflush(stdout);
waitpid(pids[i], NULL, 0);
}
printf("\n");
//
return 0; // Vaterprozess erfolgreich beenden
}
#include <stdio.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
int main(void){
pid_t pids[10]; // Platz für 10 Prozess-IDs (die Kindprozesse)
int i; // Laufvariable
for (i = 0; i < 10; ++i) {
// Der Vaterprozess erzeugt nun einen Kindprozess,
// welcher unabhängig vom Vaterprozess mit der
// erneuten Ausführung des Programms beginnt.
// Ein Kindprozess erzeugt keinen Fork von sich selbst.
pids[i] = fork();
if (pids[i] == 0) {
// dann befinden wir uns in einem der 10 Kindprozesse
// Der erste Kindprozess wartet 10 Sekunden und jeder
// weitere Kindprozess wartet 1 Sekunde kürzer als der
// vorige.
sleep(10-i);
printf ("%d BRAINS! ", i);
fflush(stdout);
exit(0); // Kindprozess erfolgreich beenden
}
}
//
// while (1);
// // hier kommt nur der Vaterprozess vorbei
// for (i = 0; i < 10; ++i){
// // Der Vaterprozess wartet nun, bis der Reihe nach jeder
// // seiner 10 Kindprozesse beendet ist. Leider wird auf das
// // Kind mit der längsten Wartezeit zuerst gewartet. Obwohl
// // die anderen Kinder längst erfolgreich beendet wurden,
// // blockiert das erste Kind eine Bereinigung der Prozesstabelle
// printf("%d ", pids[i]);
// fflush(stdout);
// waitpid(pids[i], NULL, 0);
// }
// printf("\n");
//
return 0; // Vaterprozess erfolgreich beenden
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment