Error sentinel values about go-rosenpass HOT 2 CLOSED

In Go, errors are handled using the built-in error interface, which is a simple and lightweight mechanism for representing errors. The error interface is defined as follows:

type error interface {
    Error() string
}

This interface has a single method Error() that returns a string representing the error message. Any type that implements this method automatically satisfies the error interface.

When a function in Go wants to indicate that an error has occurred, it returns an error value. If the function completes successfully, it returns nil. For example, consider a function that opens a file:

func OpenFile(filename string) (*File, error) {
    // Implementation to open the file
    // If successful, return the file and nil error
    // If an error occurs, return nil file and the corresponding error
}

To handle errors, you typically use the if statement to check if the returned error is nil or not. If it's nil, the operation was successful. Otherwise, you can handle the error appropriately. Here's an example:

func main() {
    file, err := OpenFile("example.txt")
    if err != nil {
        // Handle the error, e.g., log it, return an error, or exit the program
        fmt.Println("Error:", err)
        return
    }
    // Use the file, as it was successfully opened
    fmt.Println("File opened successfully.")
    file.Close()
}

Go encourages explicit error handling, which means you should not ignore errors returned from functions. Properly handling errors helps ensure that your programs behave predictably and reliably, even in unexpected situations.

In the example mentioned here, ErrInvalidMsgType is a custom error created by errors.New and as such implements the error interface mentioned above:

https://github.com/stv0g/go-rosenpass/blob/d7e38ecaf9e7803f2824a03ac24ac34944a53af6/messages.go#L13

from go-rosenpass.

Can we use unsigned values?
Where are unsigned values used in the application?
Unsigned values run the danger of causing subtraction where we expect addition if an attacker managed to inject them.

go-rosenpass is mainly relying signed integers.

The interface of UnmarshalBinary is mainly inspired by fmt.Fscanf() or io.Reader() which all use signed int's to return the number of octets parsed.

from go-rosenpass.