Updates

Author: djthorpe

pkg/bitwarden/client.go

@@ -66,9 +66,10 @@ const (
 )
 
 const (
-	deviceName       = "api"
-	loginScope       = "api offline_access"
-	loginApiKeyScope = "api"
+	deviceName    = "github.com/mutablelogic/go-client"
+	loginScope    = "api offline_access"
+	loginApiScope = "api"
+	clientId      = "connector"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -113,18 +114,37 @@ func (c *Client) Prelogin(email, password string) (*Session, error) {
 	return &response, nil
 }
 
-// GetToken returns a token for a session
-func (c *Client) LoginToken(session *Session) error {
+// Login returns a token for a session, or a challenge for two-factor authentication
+func (c *Client) Login(session *Session) error {
 	var request reqToken
+	var response respToken
 
+	// Check parameters
+	if session == nil {
+		return ErrBadParameter
+	}
+
+	// Set up the request
 	request.GrantType = "password"
 	request.Email = session.Email
 	request.Password = session.Password
 	request.Scope = loginScope
-	request.ClientId = "browser"
+	request.ClientId = clientId
 	request.DeviceType = deviceType()
 	request.DeviceName = deviceName
-	request.DeviceIdentifier = "00000000-0000-0000-0000-000000000000" // TODO
+	request.DeviceIdentifier = "aac2e34a-44db-42ab-a733-5322dd582c3d" // TODO
+
+	// Request -> Response
+	if payload, err := client.NewFormRequest(request, client.ContentTypeJson); err != nil {
+		return err
+	} else if err := c.Do(payload, &response, client.OptReqEndpoint(identityUrl), client.OptPath("connect/token"), client.OptReqHeader("Host", "identity.bitwarden.com")); err != nil {
+		return err
+	}
+
+	// TODO
+
+	// Return success
+	return nil
 }
 
 ///////////////////////////////////////////////////////////////////////////////

pkg/bitwarden/client_test.go

@@ -31,3 +31,19 @@ func Test_client_002(t *testing.T) {
 	data, _ := json.MarshalIndent(session, "", "  ")
 	t.Log(string(data))
 }
+
+func Test_client_003(t *testing.T) {
+	assert := assert.New(t)
+	client, err := bitwarden.New(opts.OptTrace(os.Stderr, true))
+	assert.NoError(err)
+
+	session, err := client.Prelogin("nobody@example.com", "p4ssw0rd")
+	assert.NoError(err)
+	assert.NotNil(session)
+
+	err = client.Login(session)
+	assert.NoError(err)
+
+	data, _ := json.MarshalIndent(session, "", "  ")
+	t.Log(string(data))
+}

pkg/client/client.go

@@ -1,6 +1,7 @@
 package client
 
 import (
+	"context"
 	"encoding/json"
 	"encoding/xml"
 	"fmt"
@@ -51,13 +52,13 @@ const (
 	DefaultTimeout            = time.Second * 30
 	DefaultUserAgent          = "github.com/mutablelogic/go-client"
 	PathSeparator             = string(os.PathSeparator)
+	ContentTypeAny            = "*/*"
 	ContentTypeJson           = "application/json"
 	ContentTypeTextXml        = "text/xml"
 	ContentTypeApplicationXml = "application/xml"
 	ContentTypeTextPlain      = "text/plain"
 	ContentTypeTextHTML       = "text/html"
 	ContentTypeBinary         = "application/octet-stream"
-	ContentTypeForm           = "multipart/form-data"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -110,6 +111,12 @@ func (client *Client) String() string {
 // Do a JSON request with a payload, populate an object with the response
 // and return any errors
 func (client *Client) Do(in Payload, out any, opts ...RequestOpt) error {
+	return client.DoWithContext(context.Background(), in, out, opts...)
+}
+
+// Do a JSON request with a payload, populate an object with the response
+// and return any errors. The context can be used to cancel the request
+func (client *Client) DoWithContext(ctx context.Context, in Payload, out any, opts ...RequestOpt) error {
 	client.Mutex.Lock()
 	defer client.Mutex.Unlock()
 
@@ -135,7 +142,7 @@ func (client *Client) Do(in Payload, out any, opts ...RequestOpt) error {
 		accept = in.Accept()
 		mimetype = in.Type()
 	}
-	req, err := client.request(method, accept, mimetype, in)
+	req, err := client.request(ctx, method, accept, mimetype, in)
 	if err != nil {
 		return err
 	}
@@ -182,14 +189,14 @@ func (client *Client) Request(req *http.Request, out any, opts ...RequestOpt) er
 // request creates a request which can be used to return responses. The accept
 // parameter is the accepted mime-type of the response. If the accept parameter is empty,
 // then the default is application/json.
-func (client *Client) request(method, accept, mimetype string, body io.Reader) (*http.Request, error) {
+func (client *Client) request(ctx context.Context, method, accept, mimetype string, body io.Reader) (*http.Request, error) {
 	// Return error if no endpoint is set
 	if client.endpoint == nil {
 		return nil, ErrBadParameter.With("missing endpoint")
 	}
 
 	// Make a request
-	r, err := http.NewRequest(method, client.endpoint.String(), body)
+	r, err := http.NewRequestWithContext(ctx, method, client.endpoint.String(), body)
 	if err != nil {
 		return nil, err
 	}
@@ -203,6 +210,8 @@ func (client *Client) request(method, accept, mimetype string, body io.Reader) (
 	}
 	if accept != "" {
 		r.Header.Set("Accept", accept)
+	} else {
+		r.Header.Set("Accept", ContentTypeAny)
 	}
 	if client.ua != "" {
 		r.Header.Set("User-Agent", client.ua)
@@ -256,7 +265,7 @@ func do(client *http.Client, req *http.Request, accept string, strict bool, out
 	}
 
 	// When in strict mode, check content type returned is as expected
-	if strict && accept != "" {
+	if strict && (accept != "" && accept != ContentTypeAny) {
 		if mimetype != accept {
 			return ErrUnexpectedResponse.Withf("strict mode: unexpected responsse with %q", mimetype)
 		}

pkg/client/payload.go

@@ -63,7 +63,28 @@ func NewMultipartRequest(payload any, accept string) (*Request, error) {
 	this.buffer = new(bytes.Buffer)
 
 	// Encode the payload
-	enc := multipart.NewEncoder(this.buffer)
+	enc := multipart.NewMultipartEncoder(this.buffer)
+	defer enc.Close()
+	if err := enc.Encode(payload); err != nil {
+		return nil, err
+	} else {
+		this.mimetype = enc.ContentType()
+	}
+
+	// Return success
+	return this, nil
+}
+
+// Return a new request with a Form data payload which defaults to POST. The accept
+// parameter is the accepted mime-type of the response.
+func NewFormRequest(payload any, accept string) (*Request, error) {
+	this := new(Request)
+	this.method = http.MethodPost
+	this.accept = accept
+	this.buffer = new(bytes.Buffer)
+
+	// Encode the payload
+	enc := multipart.NewFormEncoder(this.buffer)
 	defer enc.Close()
 	if err := enc.Encode(payload); err != nil {
 		return nil, err

pkg/client/requestopts.go

@@ -5,8 +5,27 @@ import (
 	"net/url"
 	"path/filepath"
 	"strings"
+
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
 )
 
+// OptReqEndpoint modifies the request endpoint for this request only
+func OptReqEndpoint(value string) RequestOpt {
+	return func(r *http.Request) error {
+		if url, err := url.Parse(value); err != nil {
+			return err
+		} else if url.Scheme == "" || url.Host == "" {
+			return ErrBadParameter.Withf("endpoint: %q", value)
+		} else if url.Scheme != "http" && url.Scheme != "https" {
+			return ErrBadParameter.Withf("endpoint: %q", value)
+		} else {
+			r.URL = url
+		}
+		return nil
+	}
+}
+
 // OptPath appends path elements onto a request
 func OptPath(value ...string) RequestOpt {
 	return func(r *http.Request) error {
@@ -44,3 +63,11 @@ func OptQuery(value url.Values) RequestOpt {
 		return nil
 	}
 }
+
+// OptReqHeader adds a header value to the request
+func OptReqHeader(name, value string) RequestOpt {
+	return func(r *http.Request) error {
+		r.Header.Set(name, value)
+		return nil
+	}
+}

pkg/client/transport.go

@@ -9,6 +9,8 @@ import (
 	"mime"
 	"net/http"
 	"time"
+
+	"github.com/mutablelogic/go-client/pkg/multipart"
 	// Packages
 )
 
@@ -80,7 +82,7 @@ func (transport *logtransport) RoundTrip(req *http.Request) (*http.Response, err
 	if transport.v {
 		data, err := req.Body.(*readwrapper).as(req.Header.Get("Content-Type"))
 		if err == nil {
-			fmt.Fprintln(transport.w, "   ", string(data))
+			fmt.Fprintf(transport.w, "  => %q\n", string(data))
 		}
 	}
 
@@ -96,7 +98,7 @@ func (transport *logtransport) RoundTrip(req *http.Request) (*http.Response, err
 			defer resp.Body.Close()
 			body, err := io.ReadAll(resp.Body)
 			if err == nil {
-				fmt.Fprintln(transport.w, "    ", string(body))
+				fmt.Fprintf(transport.w, "  <= %q\n", string(body))
 			}
 			resp.Body = io.NopCloser(bytes.NewReader(body))
 		}
@@ -137,6 +139,8 @@ func (w *readwrapper) as(mimetype string) ([]byte, error) {
 		} else {
 			return dest.Bytes(), nil
 		}
+	case multipart.ContentTypeForm:
+		return w.data.Bytes(), nil
 	default:
 		// TODO: Make this more like a hex dump
 		return []byte(hex.EncodeToString(w.data.Bytes())), nil