How to Compute File Checksums in Go: FNV and MD5 Hash Tutorial

File operations use the os package: os.Create creates/writes to files, os.ReadFile reads entire files, and file.Close closes files. The log package provides logging capabilities. Always check for errors using if err != nil { ... }.

This tutorial demonstrates how to perform file input/output operations in Go using the OS package, covering file creation with os.Create(), writing data as byte arrays using file.Write() and as strings using file.WriteString(), reading data with file.Read() into byte arrays, and using file.Seek() to move the file pointer to specific positions (0 for beginning, 1 for current position, 2 for end) to read specific portions of a file.

This section covers essential Golang features for robust application development. Error handling in Go is explicit using the error interface. Functions return errors as the second return value. errors.New() creates simple errors. Custom error types implement the error interface with additional fields. Panic signals unrecoverable errors, while Recover catches them. Type assertions convert interface values to specific types using value.(Type). Safe type assertions use value.(Type, ok) to prevent panics. Type switches test dynamic types with switch v := value.(type) {...}. They handle multiple types elegantly with default cases. File I/O uses os and io packages. Files are opened with os.Open() or os.Create(). Always check errors and close files in defer statements. bufio.Scanner reads files line by line efficiently. io.ReadAll reads entire files into memory. os.O_APPEND enables appending without overwriting. Binary files store raw bytes without encoding. Best practices include error handling, buffered operations for large files, and appropriate flags for read/write modes.

Working with files in Go involves opening files with os.Open, reading their contents with io.ReadAll, and writing processed data with os.Create and file.Write. For encryption, the source file is opened, its contents read into memory as plaintext, and then processed. Random salt generation uses the crypto/rand package to fill a byte slice with cryptographically secure random values. These foundational file operations form the basis for any file processing application, whether for encryption, compression, or transformation tasks.

Go provides file I/O operations through the 'os' package. The 'Create' function creates a new file or opens an existing one, returning a file handle. The 'Write' function writes bytes to a file, and 'Close' closes the file and releases resources. The 'fmt.Fprintln' function can write to any writer interface, including file handles, allowing flexible output destinations.

A hash function is a mathematical algorithm that transforms data into a fixed-length alphanumeric code (hash code). It serves three purposes: (1) summarizing data, (2) verifying file integrity, and (3) securing passwords on servers. Each unique document produces a unique hash code. To verify integrity: (1) The original file is passed through a hash program (like MD5) to generate a hash code, (2) This code is stored with the file, (3) When downloading, the recipient passes the file through the same program, (4) If the generated hash matches the original, the file is intact; if different, the file has been altered. This process ensures any modification produces a different hash code, alerting users to potential integrity violations.

Checksum is a numerical value calculated by summing data words and handling carries through complement operations, used to verify data integrity during transmission by comparing the calculated value with the received value to detect errors or data loss.

Hash functions (dígito verificador) are mathematical processes that transform any data into a fixed-size string of characters. The key properties include: (1) Deterministic - same input always produces same output; (2) Collision-resistant - extremely unlikely for two different inputs to produce the same output; (3) One-way - cannot reverse the process to find the original input. In CPF/CNPJ, the last two digits are checksums calculated from preceding numbers. Increasing checksum digits from 2 to 77 in Bitcoin reduces collision probability to nearly zero. This makes hash functions ideal for data integrity verification and is fundamental to Bitcoin's security architecture.

Hash functions are mathematical algorithms that convert input data into fixed-size unique strings (hashes) with two critical properties: they are fast to compute but extremely difficult to reverse-engineer, and even the smallest change to input data produces a completely different hash output. This makes hash functions essential for verifying data integrity—when files are transmitted or stored, comparing the computed hash of the received file against a known good hash reveals any tampering or corruption. Common tools like OpenSSL allow users to generate and verify hashes, enabling quick detection of unauthorized modifications to files regardless of their format (text, images, or binaries).

Hash functions are mathematical functions that convert data of any size into a fixed-length output (digital fingerprint). Key properties include: one-way irreversibility (cannot recover original data from hash), sensitivity to changes (even one character change produces a completely different hash), and fixed output length (128, 256, or 512 bits). To verify integrity, hash data at source, store the hash, then recalculate and compare when data is accessed. Matching hashes confirm data hasn't been tampered with.

Reading files in Golang uses io.ReadFile() which returns file contents as a byte slice ([]byte) along with an error. The data must be converted to string using string() function for display or processing. This byte slice format is common when reading data from files or the internet. The error handling pattern remains consistent with the comma ok syntax. Understanding byte slice handling is essential for working with file I/O in Golang.

This section covers Go's string and byte slice types. Both are memory views with headers containing pointers and lengths, but they behave differently. Strings are read-only and faster to copy because the compiler knows data won't change, enabling optimizations. Byte slices are mutable and preferred for I/O since all io package operations work with bytes. Converting between them copies the backing array, and the compiler typically cannot optimize away these copies even when data isn't modified. Escape analysis often forces heap allocation, creating garbage. In high-throughput environments, these conversions add significant overhead. For bufio.Scanner, scanner.Text() allocates new strings while scanner.Bytes() returns slices without allocation—use bytes() for performance. However, in asynchronous workers, scanner.Bytes() returns slices that may become invalid before processing completes, requiring manual copying. The choice between strings and byte slices depends on whether you need mutability and whether you're working with I/O or text processing.

For byte streams, buffered streams include BufferedInputStream and BufferedOutputStream. BufferedInputStream takes FileInputStream as its data source, and BufferedOutputStream takes FileOutputStream as its data source. BufferedInputStream has a read() method that returns integer ASCII values, and BufferedOutputStream has a write() method that accepts byte arrays.

Byte streams (InputStream/OutputStream) read/write binary data (images, music, videos). FileInputStream/FileOutputStream open files for reading/writing. Buffered streams (BufferedInputStream/BufferedOutputStream) improve performance by reading/writing larger chunks. Always close streams after use to release resources. The try-with-resources pattern simplifies resource management by automatically closing streams.

Strings in Go can be converted to byte slices using the conversion syntax `[]byte(stringValue)`. This creates a slice containing the numeric values (byte values) of each character in the string. Each character is represented as a single byte value (0-255), allowing you to work with the underlying binary representation of the string.