Handling errors from base64 decode in Go

Consider this simple base64 decode snippet:

package main

import (
    "fmt"
    "encoding/base64"
)

func main() {
    const encoded string = "aGVsbG8=" // hello
    decoded, err := base64.StdEncoding.DecodeString(encoded)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(decoded))
}

This produces hello as expected.
Now, if i intentionally pass in corrupt input, e.g.

const encoded string = "XXXXXaGVsbG8="

then i hit the panic line which gives me:

panic: illegal base64 data at input byte 11

goroutine 1 [running]:
main.main()
    /tmp/sandbox422941756/main.go:12 +0x140

Looking at the source code and this issue, seems there is not much to go by here other than matching the string literal and returning a more meaningful error message to the caller:

if err != nil {
    if strings.Contains(err.Error(), "illegal base64 data at input byte") {
        panic("\nbase64 input is corrupt, check service Key")
    }
}

There has to be a more elegant way to do this other than string matching.
What is the go-esque way to achieve this?

Look at the error type. For example,

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	encoded := "XXXXXaGVsbG8=" // corrupt
	decoded, err := base64.StdEncoding.DecodeString(encoded)
	if err != nil {
		if _, ok := err.(base64.CorruptInputError); ok {
			panic("\nbase64 input is corrupt, check service Key")
		}
		panic(err)
	}
	fmt.Println(string(decoded))
}

Output:

panic: 
base64 input is corrupt, check service Key

Looking at the implementation (unexported base64.Encoding.decode() method), if that method returns an error, it can only be of concrete type base64.CorruptInputError. This error type always produces the following error string:

func (e CorruptInputError) Error() string {
	return "illegal base64 data at input byte " + strconv.FormatInt(int64(e), 10)
}

So beside some extreme circumstances (like out of memory error, modified execution code etc.) if base64.StdEncoding.DecodeString() returns an error, its error string will always contain the string "illegal base64 data at input byte " (in the current version).

It's needless to check its error string, you can treat any non-nil returned error as the input being invalid. And the error string is an implementation detail, so you shouldn't rely on it anyway. The error string is for humans, not for code. This is how the encoding/base64 package is implemented, you can't do any finer error handling beside this (and usually there is no need to distinguish separate error cases in case of Encoding.DecodeString()).

When a package does give distinct error values for different error cases, there are techniques to handle them well. For details, check out this question:

Does go have standard Err variables?

As mentioned, in case of the encoding/base64 package a value of the concrete base64.CorruptInputError type is returned, you can use type assertion to check for that. See peterSO's answer for that.