Init task1

hw7/task1/README.md

@@ -0,0 +1,123 @@
+# Homework hw7 task1
+
+- ['Proof-of-Work'](#proof-of-work)
+- [Implementierung](#implementierung)
+    - [Modul `hash256`](#modul-hash256)
+    - [Parsen der Argumente](#parsen-der-argumente)
+    - [Subcommand 'timings'](#subcommand-timings)
+    - [Tests](#tests)
+    - [Optimierung](#optimierung)
+    - [Laufzeit Messungen](#laufzeit-messungen)
+
+## 'Proof-of-Work'
+Zur Vorbereitung einer Multithreading Anwendung beschäftigen wir uns mit dem Mining von Kryptowährungen.
+
+Das Grundprinzip bei dem sogenannten 'Proof-of-Work' basiert auf der Idee, dass Miner im Netzwerk nachweisen müssen, dass sie einen gewissen Aufwand erbracht haben.
+
+Das Durchführen eines Proof-of-Work Mechanismus bzw. das Berechnen der Ergebnisse bezeichnet man im Kontext von Blockchains als „Mining“. Die Miner versuchen dabei, durch milliardenfache Ausführung von Rechenoperationen, ein Ergebnis mit bestimmten Eigenschaften zu finden. Haben die Miner ein solches Ergebnis gefunden, werden Sie vergütet.
+
+Die Basis dieser Berechnung stellt das Multiplizieren zweier Zahlen und Hashen des Ergebnisses dar. Gesucht wird dabei ein Hashwert, der eine besondere Eigenschaft hat, z.B. indem er ein bestimmtes Muster enthält.
+
+Dieses zu findende Muster ist die sogenannte 'Difficulty'. Umso mehr Teilnehmer in einem Netzwerk aktiv sind und umso mehr Rechenkapazität somit im Netzwerk vorhanden ist, umso schwieriger wird die Difficulty.
+
+Beispiel:
+
+Gesucht ist die Zahl x, die multipliziert mit 21 (BASE) einen Hash ergibt, der am Ende das Muster "12345" hat. Eine Lösung ist die Zahl 567621, denn der Hash von 21*567621 ergibt "b6bea2a40ed1bd6d9999b2232072092f3df0e02c4b507aa3ad947367b9712345".
+
+## Implementierung
+
+### Modul `hash256`
+
+Schreiben Sie im Modul die Funktion *verify_product(base, number, difficulty) -> Option<Solution>*. Die Funnktion bildet den Hashwert des Produkts aus *base* und *number* (beide Typ `usize`)und überprüft, ob am Ende des Musters die *difficulty* steht. Stimmt das Muster nicht, so gibt die Funktion 'None' zurück. Im Erfolgsfall gibt die Funktion ein Tuple Struct zurück. `usize` im Tuple Struct (.0) ist die Zahl, die bei der Multiplikation den gesuchten Hash ergibt und der Hash (.1) selbst ist der `String`
+
+Benutzen Sie dazu die hash Methode aus der Datei `hasher_sha256.rs`, die wiederum das externe [Crate sha2][] dafür benutzt.
+
+Schreiben Sie ein Display Trait für Solution, welche die `Solution` folgendermaßen ausgibt:
+
+```text
+Number: 110918 --> hash: 0e5e21f9f25b01c820a68025f2cffeb44df1649dbc3c8c1f4932518080651234
+```
+
+Suchen Sie mit Hilfe der *verify_product()* Funktion in *main()* solange nach der Zahl, bis diese das gewünschte Muster im Hash liefert.
+
+### Parsen der Argumente
+
+Um die Parameter beim Aufruf des Programms auszuwerten, benutzen Sie das externe [Crate clap][]. Halten Sie aber die Funktion *main()* so übersichtlich wie möglich. Lagern Sie dazu die benutzte Funktionalität des Crates clap in einer eigenen Funktion aus.
+
+Die folgende Beispielausgabe von **cargo run -- --help** soll Ihnen nur als Richtlinie dienen:
+
+```text
+Running `target/debug/task1 --help`
+Proof of Work Mechanism 0.1
+Satoshi Nakamoto
+now the basics in Rust, no C anymore
+
+USAGE:
+    task1 [FLAGS] <base> <difficulty> [SUBCOMMAND]
+
+FLAGS:
+    -h, --help       Prints help information
+    -v               Sets the level of verbosity
+    -V, --version    Prints version information
+
+ARGS:
+    <base>          Sets the base to use
+    <difficulty>    Sets the difficulty to use
+
+SUBCOMMANDS:
+    help       Prints this message or the help of the given subcommand(s)
+    timings    controls timing features
+```
+
+Der `-v` Parameter ist optional, muss somit nicht implementiert werden.
+
+Beim Aufruf **cargo run -- 42 12345** erhalten Sie als Ausgabe:
+
+```text
+Using base: 42
+Using difficulty: 12345
+Please wait ...
+Number: 567621 --> hash: b6bea2a40ed1bd6d9999b2232072092f3df0e02c4b507aa3ad947367b9712345
+
+```
+
+### Subcommand 'timings'
+
+Das Subcommand 'timings' soll die Zeit ausgeben, die für das Suchen des Hashwertes benötigt wurde. Nutzen Sie dazu das [Crate time][]. Nur wenn beim Aufruf des Programms zusätzlich das Subcommand timings angegeben wird, wird eine Zeitmessung ausgeführt, welche als Ergebnis die Laufzeit der Suche ausgibt. Achten Sie darauf, wirklich nur die 'Suche' zu vermessen.
+
+Beim Aufruf **cargo run -- 42 12345 timings** erhalten Sie als Ausgabe:
+
+```text
+Using base: 42
+Using difficulty: 12345
+Please wait ...
+Number: 567621 --> hash: b6bea2a40ed1bd6d9999b2232072092f3df0e02c4b507aa3ad947367b9712345
+(Duration: 9s / 9871ms / 9871841us)
+```
+
+Geben Sie das erhaltene Ergebnis jeweils in ganzen
+
+- Sekunden
+- Millisekunden und
+- Mikrosekunden
+
+aus.
+
+### Tests
+
+Binden Sie die `unit_tests.rs` ein. Ebenfalls befindet sich ein Test in der Datei `hasher_sha256.rs`
+
+### Optimierung
+
+Nutzen Sie das Unix Tool **time**, um zusätzliche Ausgaben über die Laufzeit Ihres Programms zu erhalten (Antworten in die Datei `ANSWERS.md`):
+
+- Wie ist die Ausgabe von **time** zu interpretieren?
+- Welche Laufzeiten erhalten Sie, wenn Sie `--release` benutzen?
+
+### Laufzeit Messungen
+
+Welche (ungefähre) Abhängigkeit der Laufzeit von der Difficulty können Sie im --release Mode bestimmen? Nutzen Sie für Ihre Messungen unterschiedliche base und difficulties (Diskussion Ihrer Ergebnisse in `ANSWERS.md`)
+
+[Crate clap]: https://docs.rs/clap/
+[Crate sha2]: https://docs.rs/sha2/
+[Crate time]: https://docs.rs/time/

hw7/task1/hasher_sha256.rs

@@ -0,0 +1,106 @@
+extern crate sha2;
+#[cfg(feature = "SHA2")]
+use self::sha2::Sha256;
+
+
+pub struct Sha256;
+
+pub trait Hasher {
+    type Output: HashResult;
+    fn hash(input: &[u8]) -> Self::Output;
+}
+
+pub trait HashResult {
+    /// Get the output in hex notation.
+    fn hex(&self) -> String;
+    /// Size of the output in bytes.
+    fn size() -> usize;
+}
+
+
+impl Hasher for Sha256 {
+    type Output = [u8; 32];
+
+    fn hash(input: &[u8]) -> Self::Output {
+        use self::sha2::*;
+        let mut tmp = Sha256::new();
+        tmp.input(input);
+        let r = tmp.result().as_slice().to_vec();
+        [
+            r[0],
+            r[1],
+            r[2],
+            r[3],
+            r[4],
+            r[5],
+            r[6],
+            r[7],
+            r[8],
+            r[9],
+            r[10],
+            r[11],
+            r[12],
+            r[13],
+            r[14],
+            r[15],
+            r[16],
+            r[17],
+            r[18],
+            r[19],
+            r[20],
+            r[21],
+            r[22],
+            r[23],
+            r[24],
+            r[25],
+            r[26],
+            r[27],
+            r[28],
+            r[29],
+            r[30],
+            r[31],
+        ]
+    }
+}
+
+impl HashResult for [u8; 32] {
+    fn hex(&self) -> String {
+        const HEX: [char; 16] = [
+            '0',
+            '1',
+            '2',
+            '3',
+            '4',
+            '5',
+            '6',
+            '7',
+            '8',
+            '9',
+            'a',
+            'b',
+            'c',
+            'd',
+            'e',
+            'f',
+        ];
+        let mut tmp = String::with_capacity(32 * 2);
+        for byte in self.iter() {
+            tmp.push(HEX[*byte as usize / 16]);
+            tmp.push(HEX[*byte as usize % 16]);
+        }
+        tmp
+    }
+
+    fn size() -> usize {
+        32
+    }
+}
+
+
+#[test]
+fn test_hash() {
+    assert_eq!(
+        Sha256::hash("test".as_bytes()).hex(),
+        "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
+    );
+}

hw7/task1/unit_tests.rs

@@ -0,0 +1,52 @@
+#[cfg(test)]
+mod tests {
+    use hash256;
+
+    #[test]
+    fn test_verify1() {
+        assert_eq!(
+            hash256::verify_product(42, 567621, "12345"),
+            Some(hash256::Solution(
+                567621,
+                "b6bea2a40ed1bd6d9999b2232072092f3df0e02c4b507aa3ad947367b9712345"
+                    .to_string(),
+            ))
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_verify2() {
+        assert_eq!(
+            hash256::verify_product(41, 567621, "12345"),
+            Some(hash256::Solution(
+                567621,
+                "b6bea2a40ed1bd6d9999b2232072092f3df0e02c4b507aa3ad947367b9712345"
+                    .to_string(),
+            ))
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_verify3() {
+        assert_eq!(
+            hash256::verify_product(42, 567620, "12345"),
+            Some(hash256::Solution(
+                567621,
+                "b6bea2a40ed1bd6d9999b2232072092f3df0e02c4b507aa3ad947367b9712345"
+                    .to_string(),
+            ))
+        );
+    }
+
+    #[test]
+    fn test_verify4() {
+        assert_eq!(hash256::verify_product(41, 567621, "12345"), None);
+    }
+
+    #[test]
+    fn test_verify5() {
+        assert_eq!(hash256::verify_product(42, 567622, "12345"), None);
+    }
+}