Doing base64 decoding on a string in Go

I have a particular string that I need to run base64 decode on in Go. This string looks something like this:

qU4aaakFmjaaaaI5aaa\/EN\/aaa\/SaaaJaaa6aa+nGnk=

Please note this is not the exact same string but it does have the same shape and number of characters, padding characters and it has those \/ things on the same positions in the string.

Let's call it key.

In PHP if I run

base64_decode($key);

the decode operation is successful

If In Python I run

base64.b64decode(key)

the decode operation is once more successful. Problem is, I can't do base64 decoding on this thing in Go.

dcd, err := base64.StdEncoding.DecodeString("qU4aaakFmjaaaaI5aaa\\/EN\\/aaa\\/SaaaJaaa6aa+nGnk=")
if err != nil {
	log.Fatal(err)
}
return dcd

This will return the error

illegal base64 data at input byte 19

In the Go version, I have to escape those backslashes. It seems that the error appears at byte 19. Bearing in mind that this string that I am using as an example has the same length as the string that is actually causing the problem I would believe that the error happens right at the byte with the \ character. What can I do about this?

The alphabet of the standard Base64 does not contain backslash. So the qU4aaakFmjaaaaI5aaa\/EN\/aaa\/SaaaJaaa6aa+nGnk= input is not valid Base64 encoded string.

The forward slash is valid character in Base64, just not the backslash. It's possible the \/ is a sequence designating a single slash. If so, replace the \/ sequences with a single / and you're good to go.

For example:

s := `qU4aaakFmjaaaaI5aaa\/EN\/aaa\/SaaaJaaa6aa+nGnk=`
s = strings.ReplaceAll(s, `\/`, `/`)
dcd, err := base64.StdEncoding.DecodeString(s)
if err != nil {
	log.Fatal(err)
}

fmt.Println(string(dcd))

Which outputs (try it on the Go Playground):

�Ni��6�i�9i����i��i��i��i��y

If \/ is not a special sequence and you want to discard all invalid characters from the input, this is how it could be done:

var valid = map[rune]bool{}

func init() {
	for _, r := range "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" {
		valid[r] = true
	}
}

func clean(s string) string {
	return strings.Map(func(r rune) rune {
		if valid[r] {
			return r
		}
		return -1
	}, s)
}

func main() {
	s := `qU4aaakFmjaaaaI5aaa\/EN\/aaa\/SaaaJaaa6aa+nGnk=`
	s = clean(s)
	dcd, err := base64.StdEncoding.DecodeString(s)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(dcd))
}

Output is the same. Try this one on the Go Playground.