Merge pull request #4 from haileyok/hailey/cleanup

reorganize some things

README.md

···
         return err
     }
 
-    k, err := oauth.ParseJWKFromBytes(b)
+    k, err := helpers.ParseJWKFromBytes(b)
     if err != nil {
         return err
     }
···
         return err
     }
 
-    return e.JSON(200, oauth.CreateJwksResponseObject(pubKey))
+    return e.JSON(200, helpers.CreateJwksResponseObject(pubKey))
 }
 ```
 
···
     return err
 }
 
-k, err := oauth.ParseJWKFromBytes(b)
+k, err := helpers.ParseJWKFromBytes(b)
 if err != nil {
     return err
 }
 
-cli, err := oauth.NewClient(oauth.ClientArgs{
+cli, err := helpers.NewClient(oauth.ClientArgs{
     ClientJwk: k,
     ClientId: clientId,
     RedirectUri: callbackUrl,
···
 You'll need to create a private DPoP JWK for the user before directing them to their PDS to authenticate. You'll need to store this in a later step, and you will need to pass it along inside the PAR request, so go ahead and marshal it as well. 
 
 ```go
-k, err := oauth.GenerateKey(nil)
+k, err := helpers.GenerateKey(nil)
 if err != nil {
     return err
 }
···
 oauthSession, err := s.getOauthSession(e.Request().Context(), did)
 
 // Parse the user's JWK to pass into arguments
-privateJwk, err := oauth.ParseJWKFromBytes([]byte(oauthSession.DpopPrivateJwk))
+privateJwk, err := helpers.ParseJWKFromBytes([]byte(oauthSession.DpopPrivateJwk))
 if err != nil {
 	return nil, false, err
 }

cmd/helper/main.go

···
 	"encoding/json"
 	"os"
 
-	oauth "github.com/haileyok/atproto-oauth-golang"
+	oauth_helpers "github.com/haileyok/atproto-oauth-golang/helpers"
 	"github.com/urfave/cli/v2"
 )
 
···
 			inputPrefix := cmd.String("prefix")
 			prefix = &inputPrefix
 		}
-		key, err := oauth.GenerateKey(prefix)
+		key, err := oauth_helpers.GenerateKey(prefix)
 		if err != nil {
 			return err
 		}

cmd/web_server_demo/handle_auth.go

···
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/gorilla/sessions"
-	oauth "github.com/haileyok/atproto-oauth-golang"
+	oauth_helpers "github.com/haileyok/atproto-oauth-golang/helpers"
 	"github.com/labstack/echo-contrib/session"
 	"github.com/labstack/echo/v4"
 	"gorm.io/gorm/clause"
···
 		return err
 	}
 
-	dpopPrivateKey, err := oauth.GenerateKey(nil)
+	dpopPrivateKey, err := oauth_helpers.GenerateKey(nil)
 	if err != nil {
 		return err
 	}
···
 		return fmt.Errorf("incoming iss did not match authserver iss")
 	}
 
-	jwk, err := oauth.ParseJWKFromBytes([]byte(oauthRequest.DpopPrivateJwk))
+	jwk, err := oauth_helpers.ParseJWKFromBytes([]byte(oauthRequest.DpopPrivateJwk))
 	if err != nil {
 		return err
 	}

cmd/web_server_demo/main.go

···
 
 	"github.com/gorilla/sessions"
 	oauth "github.com/haileyok/atproto-oauth-golang"
+	oauth_helpers "github.com/haileyok/atproto-oauth-golang/helpers"
 	_ "github.com/joho/godotenv/autoload"
 	"github.com/labstack/echo-contrib/session"
 	"github.com/labstack/echo/v4"
···
 	db           *gorm.DB
 	oauthClient  *oauth.Client
 	xrpcCli      *oauth.XrpcClient
-	jwksResponse *oauth.JwksResponseObject
+	jwksResponse *oauth_helpers.JwksResponseObject
 }
 
 type TemplateRenderer struct {
···
 		return nil, err
 	}
 
-	k, err := oauth.ParseJWKFromBytes(b)
+	k, err := oauth_helpers.ParseJWKFromBytes(b)
 	if err != nil {
 		return nil, err
 	}
···
 		db:           db,
 		oauthClient:  c,
 		xrpcCli:      xrpcCli,
-		jwksResponse: oauth.CreateJwksResponseObject(pubKey),
+		jwksResponse: oauth_helpers.CreateJwksResponseObject(pubKey),
 	}, nil
 }
 

cmd/web_server_demo/user.go

···
 	"time"
 
 	oauth "github.com/haileyok/atproto-oauth-golang"
+	oauth_helpers "github.com/haileyok/atproto-oauth-golang/helpers"
 	"github.com/labstack/echo-contrib/session"
 	"github.com/labstack/echo/v4"
 )
···
 	}
 
 	if oauthSession.Expiration.Sub(time.Now()) <= 5*time.Minute {
-		privateJwk, err := oauth.ParseJWKFromBytes([]byte(oauthSession.DpopPrivateJwk))
+		privateJwk, err := oauth_helpers.ParseJWKFromBytes([]byte(oauthSession.DpopPrivateJwk))
 		if err != nil {
 			return nil, err
 		}
···
 
 	oauthSession, err := s.getOauthSession(e.Request().Context(), did)
 
-	privateJwk, err := oauth.ParseJWKFromBytes([]byte(oauthSession.DpopPrivateJwk))
+	privateJwk, err := oauth_helpers.ParseJWKFromBytes([]byte(oauthSession.DpopPrivateJwk))
 	if err != nil {
 		return nil, false, err
 	}

generic.go helpers/generic.go

···
-package oauth
+package helpers
 
 import (
 	"crypto/ecdsa"
 	"crypto/elliptic"
 	"crypto/rand"
-	"crypto/sha256"
-	"encoding/base64"
-	"encoding/hex"
 	"fmt"
 	"net/url"
 	"time"
···
 	return key, nil
 }
 
-func isSafeAndParsed(ustr string) (*url.URL, error) {
+func IsUrlSafeAndParsed(ustr string) (*url.URL, error) {
 	u, err := url.Parse(ustr)
 	if err != nil {
 		return nil, err
···
 	return u, nil
 }
 
-func getPrivateKey(key jwk.Key) (*ecdsa.PrivateKey, error) {
+func GetPrivateKey(key jwk.Key) (*ecdsa.PrivateKey, error) {
 	var pkey ecdsa.PrivateKey
 	if err := key.Raw(&pkey); err != nil {
 		return nil, err
···
 	return &pkey, nil
 }
 
-func getPublicKey(key jwk.Key) (*ecdsa.PublicKey, error) {
+func GetPublicKey(key jwk.Key) (*ecdsa.PublicKey, error) {
 	var pkey ecdsa.PublicKey
 	if err := key.Raw(&pkey); err != nil {
 		return nil, err
···
 func ParseJWKFromBytes(b []byte) (jwk.Key, error) {
 	return jwk.ParseKey(b)
 }
-
-func generateToken(len int) (string, error) {
-	b := make([]byte, len)
-	if _, err := rand.Read(b); err != nil {
-		return "", err
-	}
-
-	return hex.EncodeToString(b), nil
-}
-
-func generateCodeChallenge(pkceVerifier string) string {
-	h := sha256.New()
-	h.Write([]byte(pkceVerifier))
-	hash := h.Sum(nil)
-	return base64.RawURLEncoding.EncodeToString(hash)
-}

internal/helpers/generic.go

···
+package helpers
+
+import (
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+)
+
+func GenerateToken(len int) (string, error) {
+	b := make([]byte, len)
+	if _, err := rand.Read(b); err != nil {
+		return "", err
+	}
+
+	return hex.EncodeToString(b), nil
+}
+
+func GenerateCodeChallenge(pkceVerifier string) string {
+	h := sha256.New()
+	h.Write([]byte(pkceVerifier))
+	hash := h.Sum(nil)
+	return base64.RawURLEncoding.EncodeToString(hash)
+}

oauth.go

···
 
 	"github.com/golang-jwt/jwt/v5"
 	"github.com/google/uuid"
+	"github.com/haileyok/atproto-oauth-golang/helpers"
+	internal_helpers "github.com/haileyok/atproto-oauth-golang/internal/helpers"
 	"github.com/lestrrat-go/jwx/v2/jwk"
 )
 
···
 		}
 	}
 
-	clientPkey, err := getPrivateKey(args.ClientJwk)
+	clientPkey, err := helpers.GetPrivateKey(args.ClientJwk)
 	if err != nil {
 		return nil, fmt.Errorf("could not load private key from provided client jwk: %w", err)
 	}
···
 }
 
 func (c *Client) ResolvePdsAuthServer(ctx context.Context, ustr string) (string, error) {
-	u, err := isSafeAndParsed(ustr)
+	u, err := helpers.IsUrlSafeAndParsed(ustr)
 	if err != nil {
 		return "", err
 	}
···
 }
 
 func (c *Client) FetchAuthServerMetadata(ctx context.Context, ustr string) (*OauthAuthorizationMetadata, error) {
-	u, err := isSafeAndParsed(ustr)
+	u, err := helpers.IsUrlSafeAndParsed(ustr)
 	if err != nil {
 		return nil, err
 	}
···
 
 	parUrl := authServerMeta.PushedAuthorizationRequestEndpoint
 
-	state, err := generateToken(10)
+	state, err := internal_helpers.GenerateToken(10)
 	if err != nil {
 		return nil, fmt.Errorf("could not generate state token: %w", err)
 	}
 
-	pkceVerifier, err := generateToken(48)
+	pkceVerifier, err := internal_helpers.GenerateToken(48)
 	if err != nil {
 		return nil, fmt.Errorf("could not generate pkce verifier: %w", err)
 	}
 
-	codeChallenge := generateCodeChallenge(pkceVerifier)
+	codeChallenge := internal_helpers.GenerateCodeChallenge(pkceVerifier)
 	codeChallengeMethod := "S256"
 
 	clientAssertion, err := c.ClientAssertionJwt(authServerUrl)
···
 		params.Set("login_hint", loginHint)
 	}
 
-	_, err = isSafeAndParsed(parUrl)
+	_, err = helpers.IsUrlSafeAndParsed(parUrl)
 	if err != nil {
 		return nil, err
 	}

oauth_test.go

···
 	"os"
 	"testing"
 
+	"github.com/haileyok/atproto-oauth-golang/helpers"
 	_ "github.com/joho/godotenv/autoload"
 	"github.com/stretchr/testify/assert"
 )
···
 		panic(err)
 	}
 
-	k, err := ParseJWKFromBytes(b)
+	k, err := helpers.ParseJWKFromBytes(b)
 	if err != nil {
 		panic(err)
 	}
···
 	assert := assert.New(t)
 
 	prefix := "testing"
-	_, err := GenerateKey(&prefix)
+	_, err := helpers.GenerateKey(&prefix)
 	assert.NoError(err)
 }
 
···
 	}
 
 	prefix := "testing"
-	dpopPriv, err := GenerateKey(&prefix)
+	dpopPriv, err := helpers.GenerateKey(&prefix)
 	if err != nil {
 		panic(err)
 	}

xrpc.go

···
 	"github.com/carlmjohnson/versioninfo"
 	"github.com/golang-jwt/jwt/v5"
 	"github.com/google/uuid"
+	"github.com/haileyok/atproto-oauth-golang/internal/helpers"
 	"github.com/lestrrat-go/jwx/v2/jwk"
 )
 
···
 		"jti": uuid.NewString(),
 		"htm": method,
 		"htu": url,
-		"ath": generateCodeChallenge(accessToken),
+		"ath": helpers.GenerateCodeChallenge(accessToken),
 	}
 
 	if nonce != "" {