package main
import (
"context"
"crypto/rand"
"database/sql"
"encoding/base64"
"errors"
"fmt"
"io"
"log"
"net/http"
"os"
"time"
"golang.org/x/oauth2"
"golang.org/x/oauth2/google"
"google.golang.org/api/calendar/v3"
googleoauth "google.golang.org/api/oauth2/v2"
"google.golang.org/api/option"
)
const (
baseURL = "http://localhost:9000"
envKeyGCP = "GCP_CREDENTIALS_FILE"
)
type googleClient struct {
http *http.Client
}
type userID int
type googleUserInternalID int
var (
gcpCredsFile = os.Getenv(envKeyGCP)
errNoToken = fmt.Errorf("no Google token, or at least none that contains the scopes we need")
)
func newGoogleClient(logger *log.Logger, db *sql.DB, mux *http.ServeMux) (*googleClient, error) {
if gcpCredsFile == "" {
return nil, fmt.Errorf("%s is not set", envKeyGCP)
}
b, err := os.ReadFile(gcpCredsFile)
if err != nil {
return nil, fmt.Errorf("unable to read client secret file: %v", err)
}
// If modifying these scopes, delete your previously saved token.json.
loginConfig, err := google.ConfigFromJSON(b, calendar.CalendarEventsScope)
if err != nil {
return nil, fmt.Errorf("unable to parse client secret file to config: %v", err)
}
registerConfig, err := google.ConfigFromJSON(b, calendar.CalendarEventsScope)
if err != nil {
return nil, fmt.Errorf("unable to parse client secret file to config: %v", err)
}
loginConfig.RedirectURL = baseURL + "/login/google/callback"
registerConfig.RedirectURL = baseURL + "/register/google/callback"
mux.HandleFunc("/login/google", func(w http.ResponseWriter, r *http.Request) {
state, err := generateState(r.Context(), db)
if err != nil {
logger.Printf("unable to generate random state: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
w.Header().Set("Location", loginConfig.AuthCodeURL(state, oauth2.AccessTypeOffline))
w.WriteHeader(http.StatusMovedPermanently)
})
mux.HandleFunc("/register/google", func(w http.ResponseWriter, r *http.Request) {
state, err := generateState(r.Context(), db)
if err != nil {
logger.Printf("unable to generate random state: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
w.Header().Set("Location", registerConfig.AuthCodeURL(state, oauth2.AccessTypeOffline))
w.WriteHeader(http.StatusMovedPermanently)
})
mux.HandleFunc("/login/google/callback", func(w http.ResponseWriter, r *http.Request) {
if err := consumeState(r.Context(), db, r.FormValue("state")); err != nil {
logger.Printf("unable to consume state: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
token, err := loginConfig.Exchange(r.Context(), r.FormValue("code"))
if err != nil {
logger.Printf("unable to retrieve register token from web: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
if r.Method != http.MethodGet {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
service, err := googleoauth.NewService(r.Context(), option.WithAPIKey(token.AccessToken))
if err != nil {
logger.Printf("unable to create oauth2 service: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
userinfo, err := googleoauth.NewUserinfoV2Service(service).Me.Get().Do()
if err != nil {
logger.Printf("unable to get userinfo: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
googleUserRow := db.QueryRowContext(
r.Context(),
`
SELECT id
FROM google_users
WHERE google_id = $1
`,
userinfo.Id,
)
var id googleUserInternalID
if googleUserRow.Scan(id) != nil {
logger.Printf("unable to get google user id: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
row := db.QueryRowContext(
r.Context(),
`
SELECT
id
FROM users
INNER JOIN google_users ON google_users.user_id = users.id
WHERE google_users.google_id = $1
`,
id,
)
var userID int
if err := row.Scan(userID); err != nil {
if err == sql.ErrNoRows {
logger.Printf("tried to log in as Google user %d, but no attached user exists", id)
w.WriteHeader(http.StatusOK)
w.Write([]byte("no user for that Google account exists; register?"))
return
}
}
})
mux.HandleFunc("/register/google/callback", func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
if err := consumeState(r.Context(), db, r.FormValue("state")); err != nil {
logger.Printf("unable to consume state: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
token, err := registerConfig.Exchange(r.Context(), r.FormValue("code"))
if err != nil {
logger.Printf("unable to retrieve login token from web: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
service, err := googleoauth.NewService(r.Context(), option.WithAPIKey(token.AccessToken))
if err != nil {
logger.Printf("unable to create oauth2 service: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
userinfo, err := googleoauth.NewUserinfoV2Service(service).Me.Get().Do()
if err != nil {
logger.Printf("unable to get userinfo: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
googleUserRow := db.QueryRowContext(
r.Context(),
`
SELECT id, user_id
FROM google_users
WHERE external_id = $2
`,
userinfo.Id,
)
var (
googleUserID int
userID int
)
if googleUserRow.Scan(&googleUserID, &userID) != sql.ErrNoRows {
w.WriteHeader(http.StatusOK)
w.Write([]byte(
`
This Google account is already bound to a Mainframe account. Log in?
`,
))
return
}
if googleUserID != 0 && userID == 0 {
// Row in google_user_ids exists, row in users doesn't: Previous registration left
// off partway through. Continue.
}
if _, err := db.ExecContext(
r.Context(),
`
INSERT INTO google_links (
access_token,
token_type,
refresh_token,
expires_at
) VALUES (
$1, $2, $3, $4, $5
)
`,
token.AccessToken,
token.TokenType,
token.RefreshToken,
token.Expiry,
userinfo.Id,
); err != nil {
logger.Printf("unable to insert google link: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
googleUserResult, err := db.ExecContext(
r.Context(),
`
INSERT INTO google_users (
external_id,
email,
verified_email,
family_name,
given_name,
name,
picture,
gender,
hosted_domain,
link,
locale
) VALUES (
$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12
)
`,
userinfo.Id,
userinfo.Email,
userinfo.VerifiedEmail,
userinfo.FamilyName,
userinfo.GivenName,
userinfo.Name,
userinfo.Picture,
userinfo.Gender,
userinfo.Hd,
userinfo.Link,
userinfo.Locale,
)
if err != nil {
logger.Printf("unable to insert google user: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
googleUserID, err := googleUserResult.LastInsertId()
if err != nil {
logger.Printf("unable to get google user id: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
if _, err := db.ExecContext(
r.Context(),
`
UPDATE google_links
SET google_user_id = $1
WHERE id = $2
`,
googleUserID,
); err != nil {
logger.Printf("unable to insert google user: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
userResult, err := db.ExecContext(
r.Context(),
`
INSERT INTO users (
) VALUES (
)
`,
)
if err != nil {
logger.Printf("unable to insert user: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
userID, err := userResult.LastInsertId()
if err != nil {
logger.Printf("unable to get user id: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
if _, err := db.ExecContext(
r.Context(),
`
UPDATE google_users
SET user_id = $1
WHERE id = $2
`,
userID,
googleUserID,
); err != nil {
logger.Printf("unable to insert google user: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
})
return &googleClient{
http: &http.Client{},
}, nil
}
// tokenForUser returns a Google API token that fulfills the given scope for the
// given Google user internal ID. If there is none, errNoToken is returned.
func tokenForUser(
ctx context.Context,
logger *log.Logger,
mux *http.ServeMux,
db *sql.DB,
googleUserInternalID googleUserInternalID,
scope string,
) (*oauth2.Token, error) {
row := db.QueryRowContext(
ctx,
`
SELECT
access_token,
token_type,
refresh_token,
expires_at
FROM google_links
INNER JOIN google_link_scopes
ON google_links.id = google_link_scopes.google_link_id
INNER JOIN google_users
ON google_links.google_user_id = google_users.id
WHERE
google_user.id = $1
AND
google_link_scopes.scope = $2
ORDER BY expires_at DESC
LIMIT 1
`,
googleUserInternalID,
scope,
)
token := oauth2.Token{}
var expiry string
if err := row.Scan(
&token.AccessToken,
&token.TokenType,
&token.RefreshToken,
&expiry,
); err != nil {
return nil, fmt.Errorf("can't look up Google link token: %w", err)
}
var err error
token.Expiry, err = time.Parse(time.RFC3339, expiry)
if err != nil {
return nil, fmt.Errorf("invalid datetime in Google link expires_at column `%s`: %w", expiry, err)
}
return &token, nil
}
func generateState(ctx context.Context, db *sql.DB) (string, error) {
data := make([]byte, 1024)
if _, err := io.ReadFull(rand.Reader, data); err != nil {
return "", err
}
s := base64.StdEncoding.EncodeToString(data)
if _, err := db.ExecContext(
ctx,
`
INSERT INTO google_oauth_states (
state
) VALUES (
$1
)
`,
s,
); err != nil {
return "", err
}
return s, nil
}
func consumeState(ctx context.Context, db *sql.DB, state string) error {
row := db.QueryRowContext(
ctx,
`
SELECT id, created_at
FROM google_oauth_states
WHERE state = $1
`,
state,
)
var (
id int
createdAtStr string
)
if err := row.Scan(&id, &createdAtStr); err != nil {
return fmt.Errorf("cannot scan row: %w", err)
}
if id == 0 {
return errors.New("state not found")
}
if _, err := db.ExecContext(
ctx,
`
DELETE FROM google_oauth_states
WHERE id = $1
`,
id,
); err != nil {
return fmt.Errorf("cannot delete state: %w", err)
}
createdAt, err := time.Parse(time.DateTime, createdAtStr)
if err != nil {
return fmt.Errorf("cannot parse created_at: %w", err)
}
if time.Since(createdAt) > 5*time.Minute {
return errors.New("state expired")
}
return nil
}