OTP Generated by Google Authenticator not validated by the Library's OTP

[Cprime50]

I am using this library to generate a QR code that I connect to Google Authenticator. However, the OTP generated by Google Authenticator doesn't get validated by the library.

version of package

github.com/pquerna/otp v1.4.0

go version

go version go1.22.4 linux/amd64

code:

package main

import (
	"fmt"
	"image/png"
	"log"
	"os"

	"github.com/pquerna/otp"
	"github.com/pquerna/otp/totp"
)

func main() {
	key, err := totp.Generate(totp.GenerateOpts{
		Issuer:      "localhost:8000",
		AccountName: "test@mail.com",
		SecretSize:  32,
	})
	if err != nil {
		log.Fatalf("Failed to generate OTP: %v", err)
	}

	qrImage, err := key.Image(256, 256)
	if err != nil {
		log.Fatalf("Failed to generate QR code image: %v", err)
	}
	file, err := os.Create("otp_qrcode.png")
	if err != nil {
		log.Fatalf("Failed to create file for QR code: %v", err)
	}
	defer file.Close()
	if err := png.Encode(file, qrImage); err != nil {
		log.Fatalf("Failed to save QR code image: %v", err)
	}
	fmt.Println("QR code generated and saved as otp_qrcode.png")

	fmt.Print("Enter the OTP code from your authenticator app: ")
	var otpCode string
	fmt.Scanln(&otpCode)

	valid := totp.Validate(otpCode, key.Secret())
	if valid {
		fmt.Println("OTP verified successfully!")
	} else {
		fmt.Println("Invalid OTP code.")
	}
}

to reproduce:
Run the code provided above.
Scan the generated QR code using Google Authenticator.
Enter the OTP code displayed in Google Authenticator into the terminal.

[KEINOS]

Running your code, I can not reproduce the error in my environment. All the authenticator apps below returns as success, "OTP verified successfully!"

• Authenticators
  • Android 9 (Kernel 4.9.148)
    • Google Authenticator 6.0 ... OK
    • Microsoft Authenticator 6.2407.5108 ... OK
  • iPhone (iOS 17.6.1)
    • Google Authenticator 4.2.1 ... OK
    • Microsoft Authenticator 6.8.14 ... OK
• Code executed via macOS, Linux (Alpine, Ubuntu via Docker) @ go1.23.0
• Package: github.com/pquerna/otp v1.4.0

In my experience, the time zone and/or NTP are not set correctly in such cases.

[the-real-i9]

Hi, @Cprime50. I reproduced your code and it worked for me.

Go version (Latest)

go version go1.23.0 linux/amd64

I don't think this issue has anything to do with Go's version.

Package version

github.com/pquerna/otp v1.4.0

[yogo1212]

I've found that sometimes the secret parameter is pushed to the end of the query. Then, the Google Authenticator tells me to use the camera. The ios camera app adds the TOTP params to the keystore and produces working codes.

While it is funny that Google asks me to use Apple software because they suck, maybe there's good reason for this package to make sure the secret is the first parameter in the query.

[yogo1212]

package main

import (
	"crypto/rand"
	"log"
	"github.com/pquerna/otp"
	"github.com/pquerna/otp/totp"
)

func main() {
	secret := make([]byte, 20)
	rand.Read(secret)

	t, err := totp.Generate(totp.GenerateOpts{
		"issuer",
		"id@qwer.com",
		45,
		uint(len(secret)),
		secret,
		otp.DigitsEight,
		otp.AlgorithmSHA256,
		rand.Reader,
	})
	if err != nil {
		log.Fatal(err)
	}

	log.Println(t.URL())
}

secret at the end -> gauth throws in the towel

[yogo1212]

https://github.com/pquerna/otp/blob/master/internal/encode.go#L21

this is the culprit.
can't sort the keys.

[yogo1212]

i'll create a PR

[KEINOS]

According to the below specs, "secret" is the only required parameter and all the examples begins with "secret" parameter.

• https://github.com/google/google-authenticator/wiki/Key-Uri-Format
• https://docs.yubico.com/yesdk/users-manual/application-oath/uri-string-format.html
• https://docs.yubico.com/yesdk/users-manual/application-oath/oath-credentials.html

Due to the random nature of Golang maps, "secret" does not appear statically in the first parameter. Therefore, I was almost convinced that GoogleAuthenticator had a rule that the first parameter had to be "secret".

But on the other hand, the specifications do not stipulate that the first parameter must be "secret".

I have looked at the old source code of GoogleAuthenticator for both Android and iOS and it seems that neither of them check/restricts the order of the parameters in the OTP URI.

So even if it does no harm if the first parameter is forced to be "secret", certain precautions should be taken.

Because I suspect that there is a deeper reason for this.

I created the below test code. It creates QR code images for both URI with "secret" parameter at the head and the tail. And they both worked fine on my Android and iPhone authenticators (Google Authenticator and Microsoft Authenticator).

@yogo1212 Does the blow reproduce the problem?

TEST CODE

package main

import (
	"image"
	"image/png"
	"os"

	"github.com/boombuler/barcode"
	"github.com/boombuler/barcode/qr"
)

func main() {
	const (
		// valid URI which begins with a secret parameter
		validURI = "otpauth://totp/localhost:8000:test@mail.com?" +
			"secret=3GTPYMOZFQGN26SXJRB3RUHFR4NESG4PRNFX2PBGRDBGKRYNRE4A&algorithm=SHA1&digits=6&issuer=localhost:8000&period=30"
		// invalid URI which ends with a secret parameter
		invalidURI = "otpauth://totp/localhost:8000:test@mail.com?" +
			"algorithm=SHA1&digits=6&issuer=localhost:8000&period=30&secret=3GTPYMOZFQGN26SXJRB3RUHFR4NESG4PRNFX2PBGRDBGKRYNRE4A"
	)

	// generate QR code for valid URI and save it to file
	okImage, err := getQR(validURI, 256, 256)
	panicOnError(err)

	err = saveImg(okImage, "valid.png")
	panicOnError(err)

	// generate QR code for invalid URI and save it to file
	ngImage, err := getQR(invalidURI, 256, 256)
	panicOnError(err)

	err = saveImg(ngImage, "invalid.png")
	panicOnError(err)
}

func saveImg(img image.Image, filename string) error {
	file, err := os.Create(filename)
	if err != nil {
		return err
	}
	defer file.Close()

	if err := png.Encode(file, img); err != nil {
		return err
	}

	return nil
}

func getQR(orig string, width int, height int) (image.Image, error) {
	b, err := qr.Encode(orig, qr.M, qr.Auto)
	if err != nil {
		return nil, err
	}

	b, err = barcode.Scale(b, width, height)
	if err != nil {
		return nil, err
	}

	return b, nil
}

func panicOnError(err error) {
	if err != nil {
		panic(err)
	}
}

[yogo1212]

@KEINOS there's a draft RFC that (seemingly) didn't go through (err.. it expired. where is my mind).
(tracking page for that rfc)
until there's standardisation, we have to go by what works with the software in the field. sadly.

the rfc links to a blog post exploring the situation. google worked on the thing until they were happy with out, producing a de-facto-but-not-really standard, and left the cleanup for the rest of the world.

i created #95 in the meantime.

[KEINOS]

@yogo1212

That's very informative! Thank you.

I am so tired of Google getting bored halfway through designing something - and then expecting the rest of us to just figure out what they meant.

• Why is there no formal specification for otpauth URls? @ shkspr.mobi

Indeed, the blog explains everything.

until there's standardisation, we have to go by what works with the software in the field. sadly.

I do understand and agree.

But what I'm pointing out here is that I can not reproduce the problem on any device and AuthApps that I have.
Even forcing the last parameter be the "secret".

So, I have a hunch that the order of the parameters itself is not the cause of the problem.

However, let's assume that in the case of GoogleAuthenticator, the first parameter must be "secret" and is mandatory.

If this is due to the order of the parameters, it will lead to conflicts in the future if other providers choose different specifications. As noted in the blog, different providers have different specifications.

To continue the discussion for closing, shouldn't the order of the optional parameters be configurable as follows?
This should ensure backward compatibility of the package as well.

- func EncodeQuery(v url.Values) string {...}
+ func EncodeQuery(v url.Values, paramKeys ...string) string {
+     if len(paramKeys) == 0 {
+         return ...(original behaviour)...
+     }
+
+     for _, paramKey := range paramKeys {
+         // append to the URI if paramKey exists in v
+     }
+     return ...(custom ordered)...
+ }

[yogo1212]

@KEINOS most authenticators don't impose any particular order - which is the sane thing to do.
query params aren't usually ordered anyway (maybe except for when multiple asdf[]= params are being used to construct a list). they are primarily a key-value mapping.

since we aren't aware of any other restrictions when it comes to ordering params, the solution you suggested is probably overkill.
ideally, google invests the 5 minutes to make their app more relaxed (they also don't have any standard that they can't point to to justify their behaviour).

then, the workaround could even be removed from here.

[yogo1212]

since google, apple, etc. brought us into this age, i see little reason against creating a negative review on any of the app stores, explaining this problem.

in fact, i got my hands on a relative's iphone just to do that.

This app doesn't work when the secret isn't the first parameter in the QR code. There's no reason why it shouldn't.

for those of you want to their spend their time being annoyed by this issue more productively, i can only recommend doing the same.

[KEINOS]

I agree that my propose may be a bit over the top.

in fact, i got my hands on a relative's iphone just to do that.

Can you provide us the URI and the QR code of that particular example?

I'm not trying to be offensive, just looking for a reproducible example. So we can find the actual problem and make this package handle one thing and well.

I like this package and believe that it will make my application more secure.
Thus, I want to find the cause rather than "It works, so be it" way, you know.

[yogo1212]

@KEINOS

doesn't work (QR code):

otpauth://totp/domain.com:test@domain.com?algorithm=SHA256&digits=8&issuer=domain.com&period=45&secret=DEOXGYTNWD3D6J3RNBEGCI2R45X3XO3X

does work:

otpauth://totp/domain.com:test@domain.com?secret=DEOXGYTNWD3D6J3RNBEGCI2R45X3XO3X&algorithm=SHA256&digits=8&issuer=domain.com&period=45

this is for the cross-checking the generated otp code:

oathtool --totp=SHA256 --digits=8 -s 45s -b DEOXGYTNWD3D6J3RNBEGCI2R45X3XO3X

[yogo1212]

█████████████████████████████████████████████████
█████████████████████████████████████████████████
████ ▄▄▄▄▄ █▄ █▀ ████▀▀▄▄ ▀ █▀▄█ █ ▄▄█ ▄▄▄▄▄ ████
████ █   █ █  ▄▄▀▄  ██▀ ▀ █ ▄ ▀▀█▀█ ▄█ █   █ ████
████ █▄▄▄█ █▄▀█▄██ █▄▄ ▀ ▀▀▄▄██▄█▄▄  █ █▄▄▄█ ████
████▄▄▄▄▄▄▄█▄█▄▀ █ █▄▀▄█▄█ █▄█▄█ ▀ █▄█▄▄▄▄▄▄▄████
████▄▄ ▄██▄█▄ ▀▀▀█▄▄█▄  ▀▄█▀▀█ █ ▄ ▀▀▄▀▀ ▄▄█ ████
████▄▄ ▀█▀▄▀▀▀  ▄ ▄█▄█▄█▄▄█ ▀  ██▄██▀  ▀ █▄ █████
████  ▀▀▄ ▄▀ ▀▄ ██▀  █▀██▀█ ▄▄  ▄▄█ ██▀███  ▀████
█████▀▄▀▄█▄▀▀█▀█ ▄▄▀██▀▄█ ▀█ ▄▄▀ ██   ▄ ▄▀▄ ▄████
████▄▄▄█  ▄ ▀   ▄ █▀ █▄▄▀   ▀▀█▀▄█▄▄ ▄█▄▄ █ █████
████▀▄ ▄▀ ▄█▄▀▄▀▀▀▀ ██▄▀▄▀▀▀██▄ █▀▀██ █▄▀ ▀▀█████
████▀██ █▄▄▄▄█▄▄█ ██▄▀ █▀██ ▀█▄▄█ ▄ ▀  ▀ ▀▄█▀████
████ █  █ ▄▀▄ █▀▀▀   ▄ ▀▄█▄▄ ▀▄█▄█▄██ ▄ █▄▄ █████
████ ▀ ▀█ ▄██▀▄▄█▄ ▀▄▄  █▀▀▄ ▄ ▀▄ ▄▀█▀▀▀█▀ █ ████
████ █▀▄▀▀▄▄█▄█▀ ▄ ▀█▀▀  ▄▄█ █▀▀▀▄▀  ███▄▀█  ████
████▄▀▄  ▄▄▀█▄ ▄▄▀▄█ ▀▀█▄▀█ ▄ ▀  ▀▄▄ ▄█ ▄▄█▄█████
████▄██▀▄ ▄▄ ▀▀▀█▄▄▀▄▀▀█ █ ▀ █ ▄▀ █▀███▄  ▀▀▀████
█████▄▄▄▄▄▄▄▀▀▀▀▄█▄  ▀▄ ▀▄█▀██▄█   █ ▄▄▄ ▀▄  ████
████ ▄▄▄▄▄ ██ ▄▄▀▀▄█▀▄█▀ █▀▄  ▄▀▄▄▀  █▄█ █▄█▀████
████ █   █ █▀ █▀ ▀▀██  ▄▄▄ ▄▀  ▀▀ ██  ▄▄ █ ▄ ████
████ █▄▄▄█ █ ██ █▄▀▄▄▄█▀█▀ █▄█ █▀▄█▄▀▄▀█▀▄▄ ▄████
████▄▄▄▄▄▄▄█▄▄██▄▄█▄█▄▄▄▄▄▄▄█▄█▄██▄█▄█▄▄▄▄█▄█████
█████████████████████████████████████████████████
█████████████████████████████████████████████████

[yogo1212]

urgh. that looks horrible in here...