fix: build sha256 hash in a incremental way (#33)

Author: jiacai2050

book-src/02-01-sha-digest.md

@@ -5,32 +5,39 @@ There are many crypto algorithm implementations in std, `sha256`, `md5` are supp
 ```zig
 const std = @import("std");
 const fs = std.fs;
-const print = std.debug.print;
 const Sha256 = std.crypto.hash.sha2.Sha256;
 
+// In real world, this may set to page_size, usually it's 4096.
+const BUF_SIZE = 16;
+
 fn sha256_digest(
-    allocator: std.mem.Allocator,
     file: fs.File,
 ) ![Sha256.digest_length]u8 {
-    const md = try file.metadata();
-    const size = md.size();
-    const bytes = try file.reader().readAllAlloc(allocator, size);
-    defer allocator.free(bytes);
-
-    var out: [Sha256.digest_length]u8 = undefined;
-    Sha256.hash(bytes, &out, .{});
-    return out;
+    var sha256 = Sha256.init(.{});
+    const rdr = file.reader();
+
+    var buf: [BUF_SIZE]u8 = undefined;
+    var n = try rdr.read(&buf);
+    while (n != 0) {
+        sha256.update(buf[0..n]);
+        n = try rdr.read(&buf);
+    }
+
+    return sha256.finalResult();
 }
 
 pub fn main() !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
 
-    const file = try fs.cwd().openFile("build.zig", .{});
+    const file = try fs.cwd().openFile("tests/zig-zen.txt", .{});
     defer file.close();
 
-    const digest = try sha256_digest(allocator, file);
-    print("SHA-256 digest is {s}", .{std.fmt.fmtSliceHexLower(&digest)});
+    const digest = try sha256_digest(file);
+    const hex_digest = try std.fmt.allocPrint(allocator, "{s}", .{std.fmt.fmtSliceHexLower(&digest)});
+    defer allocator.free(hex_digest);
+
+    try std.testing.expectEqualStrings("2210e9263ece534df0beff39ec06850d127dc60aa17bbc7769c5dc2ea5f3e342", hex_digest);
 }
 ```

src/01-01.zig

@@ -7,7 +7,7 @@ pub fn main() !void {
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
 
-    const file = try fs.cwd().openFile("tests/hello-world.txt", .{});
+    const file = try fs.cwd().openFile("tests/zig-zen.txt", .{});
     defer file.close();
 
     const rdr = file.reader();

src/02-01.zig

@@ -1,30 +1,37 @@
 const std = @import("std");
 const fs = std.fs;
-const print = std.debug.print;
 const Sha256 = std.crypto.hash.sha2.Sha256;
 
+// In real world, this may set to page_size, usually it's 4096.
+const BUF_SIZE = 16;
+
 fn sha256_digest(
-    allocator: std.mem.Allocator,
     file: fs.File,
 ) ![Sha256.digest_length]u8 {
-    const md = try file.metadata();
-    const size = md.size();
-    const bytes = try file.reader().readAllAlloc(allocator, size);
-    defer allocator.free(bytes);
-
-    var out: [Sha256.digest_length]u8 = undefined;
-    Sha256.hash(bytes, &out, .{});
-    return out;
+    var sha256 = Sha256.init(.{});
+    const rdr = file.reader();
+
+    var buf: [BUF_SIZE]u8 = undefined;
+    var n = try rdr.read(&buf);
+    while (n != 0) {
+        sha256.update(buf[0..n]);
+        n = try rdr.read(&buf);
+    }
+
+    return sha256.finalResult();
 }
 
 pub fn main() !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
 
-    const file = try fs.cwd().openFile("tests/hello-world.txt", .{});
+    const file = try fs.cwd().openFile("tests/zig-zen.txt", .{});
     defer file.close();
 
-    const digest = try sha256_digest(allocator, file);
-    print("SHA-256 digest is {s}\n", .{std.fmt.fmtSliceHexLower(&digest)});
+    const digest = try sha256_digest(file);
+    const hex_digest = try std.fmt.allocPrint(allocator, "{s}", .{std.fmt.fmtSliceHexLower(&digest)});
+    defer allocator.free(hex_digest);
+
+    try std.testing.expectEqualStrings("2210e9263ece534df0beff39ec06850d127dc60aa17bbc7769c5dc2ea5f3e342", hex_digest);
 }

tests/hello-world.txt

@@ -0,0 +1,13 @@
+ * Communicate intent precisely.
+ * Edge cases matter.
+ * Favor reading code over writing code.
+ * Only one obvious way to do things.
+ * Runtime crashes are better than bugs.
+ * Compile errors are better than runtime crashes.
+ * Incremental improvements.
+ * Avoid local maximums.
+ * Reduce the amount one must remember.
+ * Focus on code rather than style.
+ * Resource allocation may fail; resource deallocation must succeed.
+ * Memory is a resource.
+ * Together we serve the users.