feat: Initial open source commit

Author: jameshoulahan

.github/workflows/check.yml

@@ -0,0 +1,28 @@
+name: Lint and Test
+
+on: push
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get sources
+        uses: actions/checkout@v3
+
+      - name: Set up Go 1.18
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.18'
+
+      - name: Run golangci-lint
+        uses: golangci/golangci-lint-action@v3
+        with:
+          version: v1.50.0
+          args: --timeout=180s
+          skip-cache: true
+
+      - name: Run tests
+        run: go test -v ./...
+
+      - name: Run tests with race check
+        run: go test -v -race ./...

CONTRIBUTING.md

@@ -0,0 +1,10 @@
+# Contribution Policy
+
+By making a contribution to this project:
+
+1. I assign any and all copyright related to the contribution to Proton AG;
+2. I certify that the contribution was created in whole by me;
+3. I understand and agree that this project and the contribution are public
+   and that a record of the contribution (including all personal information I
+   submit with it) is maintained indefinitely and may be redistributed with
+   this project or the open source license(s) involved.

LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 James Houlahan
+Copyright (c) 2022 Proton AG
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,23 @@
+# Go Proton API
+
+<a href="https://github.com/ProtonMail/go-proton-api/actions/workflows/check.yml"><img src="https://github.com/ProtonMail/go-proton-api/actions/workflows/check.yml/badge.svg?branch=master" alt="CI Status"></a>
+<a href="https://pkg.go.dev/github.com/ProtonMail/go-proton-api"><img src="https://pkg.go.dev/badge/github.com/ProtonMail/go-proton-api" alt="GoDoc"></a>
+<a href="https://goreportcard.com/report/ProtonMail/go-proton-api"><img src="https://goreportcard.com/badge/ProtonMail/go-proton-api" alt="Go Report Card"></a>
+<a href="LICENSE"><img src="https://img.shields.io/github/license/ProtonMail/go-proton-api.svg" alt="License"></a>
+
+This repository holds Go Proton API, a Go library implementing a client and development server for (a subset of) the Proton REST API.
+
+The license can be found in the [LICENSE](./LICENSE) file.
+
+For the contribution policy, see [CONTRIBUTING](./CONTRIBUTING.md).
+
+## Environment variables
+
+Most of the integration tests run locally. The ones that interact with Proton servers require the following environment variables set:
+
+- ```GO_PROTON_API_TEST_USERNAME```
+- ```GO_PROTON_API_TEST_PASSWORD```
+
+## Contribution
+
+The library is maintained by Proton AG, and is not actively looking for contributors.

address.go

@@ -0,0 +1,46 @@
+package proton
+
+import (
+	"context"
+
+	"github.com/go-resty/resty/v2"
+	"golang.org/x/exp/slices"
+)
+
+func (c *Client) GetAddresses(ctx context.Context) ([]Address, error) {
+	var res struct {
+		Addresses []Address
+	}
+
+	if err := c.do(ctx, func(r *resty.Request) (*resty.Response, error) {
+		return r.SetResult(&res).Get("/core/v4/addresses")
+	}); err != nil {
+		return nil, err
+	}
+
+	slices.SortFunc(res.Addresses, func(a, b Address) bool {
+		return a.Order < b.Order
+	})
+
+	return res.Addresses, nil
+}
+
+func (c *Client) GetAddress(ctx context.Context, addressID string) (Address, error) {
+	var res struct {
+		Address Address
+	}
+
+	if err := c.do(ctx, func(r *resty.Request) (*resty.Response, error) {
+		return r.SetResult(&res).Get("/core/v4/addresses/" + addressID)
+	}); err != nil {
+		return Address{}, err
+	}
+
+	return res.Address, nil
+}
+
+func (c *Client) OrderAddresses(ctx context.Context, req OrderAddressesReq) error {
+	return c.do(ctx, func(r *resty.Request) (*resty.Response, error) {
+		return r.SetBody(req).Put("/core/v4/addresses/order")
+	})
+}

address_types.go

@@ -0,0 +1,27 @@
+package proton
+
+type Address struct {
+	ID    string
+	Email string
+
+	Send    Bool
+	Receive Bool
+	Status  AddressStatus
+
+	Order       int
+	DisplayName string
+
+	Keys Keys
+}
+
+type OrderAddressesReq struct {
+	AddressIDs []string
+}
+
+type AddressStatus int
+
+const (
+	AddressStatusDisabled AddressStatus = iota
+	AddressStatusEnabled
+	AddressStatusDeleting
+)

atomic.go

@@ -0,0 +1,33 @@
+package proton
+
+import "sync/atomic"
+
+type atomicUint64 struct {
+	v uint64
+}
+
+func (x *atomicUint64) Load() uint64 { return atomic.LoadUint64(&x.v) }
+
+func (x *atomicUint64) Store(val uint64) { atomic.StoreUint64(&x.v, val) }
+
+func (x *atomicUint64) Swap(new uint64) (old uint64) { return atomic.SwapUint64(&x.v, new) }
+
+func (x *atomicUint64) Add(delta uint64) (new uint64) { return atomic.AddUint64(&x.v, delta) }
+
+type atomicBool struct {
+	v uint32
+}
+
+func (x *atomicBool) Load() bool { return atomic.LoadUint32(&x.v) != 0 }
+
+func (x *atomicBool) Store(val bool) { atomic.StoreUint32(&x.v, b32(val)) }
+
+func (x *atomicBool) Swap(new bool) (old bool) { return atomic.SwapUint32(&x.v, b32(new)) != 0 }
+
+func b32(b bool) uint32 {
+	if b {
+		return 1
+	}
+
+	return 0
+}

attachment.go

@@ -0,0 +1,79 @@
+package proton
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+
+	"github.com/ProtonMail/gopenpgp/v2/crypto"
+	"github.com/go-resty/resty/v2"
+)
+
+func (c *Client) GetAttachment(ctx context.Context, attachmentID string) ([]byte, error) {
+	return c.attPool().ProcessOne(ctx, attachmentID)
+}
+
+func (c *Client) UploadAttachment(ctx context.Context, addrKR *crypto.KeyRing, req CreateAttachmentReq) (Attachment, error) {
+	var res struct {
+		Attachment Attachment
+	}
+
+	sig, err := addrKR.SignDetached(crypto.NewPlainMessage(req.Body))
+	if err != nil {
+		return Attachment{}, fmt.Errorf("failed to sign attachment: %w", err)
+	}
+
+	enc, err := addrKR.EncryptAttachment(crypto.NewPlainMessage(req.Body), req.Filename)
+	if err != nil {
+		return Attachment{}, fmt.Errorf("failed to encrypt attachment: %w", err)
+	}
+
+	if err := c.do(ctx, func(r *resty.Request) (*resty.Response, error) {
+		return r.SetResult(&res).
+			SetMultipartFormData(map[string]string{
+				"MessageID":   req.MessageID,
+				"Filename":    req.Filename,
+				"MIMEType":    string(req.MIMEType),
+				"Disposition": string(req.Disposition),
+				"ContentID":   req.ContentID,
+			}).
+			SetMultipartFields(
+				&resty.MultipartField{
+					Param:       "KeyPackets",
+					FileName:    "blob",
+					ContentType: "application/octet-stream",
+					Reader:      bytes.NewReader(enc.KeyPacket),
+				},
+				&resty.MultipartField{
+					Param:       "DataPacket",
+					FileName:    "blob",
+					ContentType: "application/octet-stream",
+					Reader:      bytes.NewReader(enc.DataPacket),
+				},
+				&resty.MultipartField{
+					Param:       "Signature",
+					FileName:    "blob",
+					ContentType: "application/octet-stream",
+					Reader:      bytes.NewReader(sig.GetBinary()),
+				},
+			).
+			Post("/mail/v4/attachments")
+	}); err != nil {
+		return Attachment{}, err
+	}
+
+	return res.Attachment, nil
+}
+
+func (c *Client) getAttachment(ctx context.Context, attachmentID string) ([]byte, error) {
+	res, err := c.doRes(ctx, func(r *resty.Request) (*resty.Response, error) {
+		return r.SetDoNotParseResponse(true).Get("/mail/v4/attachments/" + attachmentID)
+	})
+	if err != nil {
+		return nil, err
+	}
+	defer res.RawBody().Close()
+
+	return io.ReadAll(res.RawBody())
+}

attachment_types.go

@@ -0,0 +1,36 @@
+package proton
+
+import (
+	"github.com/ProtonMail/gluon/rfc822"
+)
+
+type Attachment struct {
+	ID string
+
+	Name        string
+	Size        int64
+	MIMEType    rfc822.MIMEType
+	Disposition Disposition
+	Headers     Headers
+
+	KeyPackets string
+	Signature  string
+}
+
+type Disposition string
+
+const (
+	InlineDisposition     Disposition = "inline"
+	AttachmentDisposition Disposition = "attachment"
+)
+
+type CreateAttachmentReq struct {
+	MessageID string
+
+	Filename    string
+	MIMEType    rfc822.MIMEType
+	Disposition Disposition
+	ContentID   string
+
+	Body []byte
+}

auth.go

@@ -0,0 +1,45 @@
+package proton
+
+import (
+	"context"
+
+	"github.com/go-resty/resty/v2"
+)
+
+func (c *Client) Auth2FA(ctx context.Context, req Auth2FAReq) error {
+	return c.do(ctx, func(r *resty.Request) (*resty.Response, error) {
+		return r.SetBody(req).Post("/core/v4/auth/2fa")
+	})
+}
+
+func (c *Client) AuthDelete(ctx context.Context) error {
+	return c.do(ctx, func(r *resty.Request) (*resty.Response, error) {
+		return r.Delete("/core/v4/auth")
+	})
+}
+
+func (c *Client) AuthSessions(ctx context.Context) ([]AuthSession, error) {
+	var res struct {
+		Sessions []AuthSession
+	}
+
+	if err := c.do(ctx, func(r *resty.Request) (*resty.Response, error) {
+		return r.SetResult(&res).Get("/auth/v4/sessions")
+	}); err != nil {
+		return nil, err
+	}
+
+	return res.Sessions, nil
+}
+
+func (c *Client) AuthRevoke(ctx context.Context, authUID string) error {
+	return c.do(ctx, func(r *resty.Request) (*resty.Response, error) {
+		return r.Delete("/auth/v4/sessions/" + authUID)
+	})
+}
+
+func (c *Client) AuthRevokeAll(ctx context.Context) error {
+	return c.do(ctx, func(r *resty.Request) (*resty.Response, error) {
+		return r.Delete("/auth/v4/sessions")
+	})
+}