Implementing OAuth2 Authentication Flows in Go

What is OAuth2?

OAuth2 is a widely used authorization framework that allows a third-party application to obtain limited access to an HTTP service on behalf of a user, either by orchestrating an approval interaction with the user or by allowing the third-party application to obtain access on its own behalf.

Overview of OAuth2 Flows

OAuth2 defines several authentication flows for different client types and authorization scenarios, such as:

• Authorization Code Grant: Used by server-based applications.
• Implicit Grant: Suitable for browser-based or mobile apps.
• Resource Owner Password Credentials Grant: Used in highly trusted applications.
• Client Credentials Grant: Employed when accessing the service's resources, rather than a user’s resources, such as service-oriented architectures.

Setting Up OAuth2 in a Go Application

To implement OAuth2 in a Go application, we will use the golang.org/x/oauth2 package which provides easy-to-use building blocks for the OAuth2 authentication process.

Setting Up Your Project

First, create a new Go module:

$ mkdir my-oauth-app
$ cd my-oauth-app
$ go mod init my-oauth-app

Installing the OAuth2 Package

Run the following command to add the OAuth2 package to your project:

$ go get golang.org/x/oauth2

Implementing Authorization Code Flow

To implement the Authorization Code Flow, you need to set up a few credentials in your code:

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"

    "golang.org/x/oauth2"
    "golang.org/x/oauth2/google"
)

func main() {
    conf := &oauth2.Config{
        ClientID:     "your-client-id",
        ClientSecret: "your-client-secret",
        RedirectURL:  "http://localhost:8080/callback",
        Endpoint:     google.Endpoint,
        Scopes: []string{"https://www.googleapis.com/auth/userinfo.profile"},
    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        url := conf.AuthCodeURL("state-token", oauth2.AccessTypeOffline)
        http.Redirect(w, r, url, http.StatusFound)
    })

    http.HandleFunc("/callback", func(w http.ResponseWriter, r *http.Request) {
        code := r.URL.Query().Get("code")
        token, err := conf.Exchange(context.Background(), code)
        if err != nil {
            log.Fatalf("Unable to retrieve token: %v", err)
        }
        fmt.Fprintf(w, "Access Token: %s", token.AccessToken)
    })

    log.Println("Server is running at 8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Replace your-client-id and your-client-secret with your application's credentials from the Google Developer Console.

Running the Application

To run the application, use the following command:

$ go run main.go

Navigate to http://localhost:8080 in your web browser, authorize your app, and you should see the Access Token displayed upon a successful callback.

Conclusion

With this setup, you have successfully implemented the OAuth2 Authorization Code Flow in a Go application. You can expand this further to handle additional scopes and credentials as your application requires.