From 257ea3c1fe349ee317440be5a527558f2a2fe290 Mon Sep 17 00:00:00 2001 From: Chun-Hung Tseng Date: Tue, 20 Jun 2023 17:10:43 +0200 Subject: [PATCH] Initial commit --- .github/workflows/check.yml | 28 ++ .gitignore | 5 + Documentation.md | 31 ++ LICENSE | 21 ++ README.md | 133 +++++++++ common/config.go | 96 ++++++ common/error.go | 11 + common/keyring.go | 70 +++++ common/proton_manager.go | 28 ++ common/user.go | 156 ++++++++++ constants.go | 5 + crypto.go | 168 +++++++++++ delete.go | 101 +++++++ drive.go | 162 ++++++++++ drive_test.go | 288 ++++++++++++++++++ drive_test_helper.go | 308 +++++++++++++++++++ error.go | 16 + file.go | 457 +++++++++++++++++++++++++++++ folder.go | 318 ++++++++++++++++++++ go.mod | 36 +++ go.sum | 144 +++++++++ keyring.go | 51 ++++ search.go | 180 ++++++++++++ shares.go | 25 ++ testcase/empty.txt | 0 testcase/integrationTestImage.png | Bin 0 -> 49613 bytes testcase/integrationTestImage2.png | Bin 0 -> 328557 bytes utility/init.go | 9 + volumes.go | 16 + 29 files changed, 2863 insertions(+) create mode 100644 .github/workflows/check.yml create mode 100644 .gitignore create mode 100644 Documentation.md create mode 100644 LICENSE create mode 100644 common/config.go create mode 100644 common/error.go create mode 100644 common/keyring.go create mode 100644 common/proton_manager.go create mode 100644 common/user.go create mode 100644 constants.go create mode 100644 crypto.go create mode 100644 delete.go create mode 100644 drive.go create mode 100644 drive_test.go create mode 100644 drive_test_helper.go create mode 100644 error.go create mode 100644 file.go create mode 100644 folder.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 keyring.go create mode 100644 search.go create mode 100644 shares.go create mode 100644 testcase/empty.txt create mode 100644 testcase/integrationTestImage.png create mode 100644 testcase/integrationTestImage2.png create mode 100644 utility/init.go create mode 100644 volumes.go diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml new file mode 100644 index 0000000..625a426 --- /dev/null +++ b/.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 ./... diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5ced228 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.DS_Store +.credential +.*.credential +data +config.toml \ No newline at end of file diff --git a/Documentation.md b/Documentation.md new file mode 100644 index 0000000..a48aad7 --- /dev/null +++ b/Documentation.md @@ -0,0 +1,31 @@ +# Documentation + +Since the Proton API isn't open sourced, this document serves as the team's understanding for future reference. + +# Proton Drive API + +## Terminology + +### Volume + +### Share + +### Node + +### Link + +## Encryption + +Encryption, decryption, and signature signing and verification, etc. are all performed by using the go-crypto library. + +### Login + +Proton uses SRP for logging in the users. After logging in, there is a small time window (several minutes) where users can access certain routes, which is in the `scope` field, e.g. getting user salt. + +Since the user and address key rings are encrypted with passphrase tied to salt and user password, we need to cache this information as soon as the first log in happens for future usage. + +### User Key + +### Address Key + +### Node/Link Key \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..9a180f0 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2023 Chun-Hung Tseng + +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. diff --git a/README.md b/README.md index ea85e9d..e3de74a 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,135 @@ # Proton API Bridge +Thanks to Proton open sourcing [proton-go-api](https://github.com/ProtonMail/go-proton-api) and the web, iOS, and Android client codebases, we don't need to completely reverse engineer the APIs by observing the web client traffic! + +[proton-go-api](https://github.com/ProtonMail/go-proton-api) provides the basic building blocks of API calls and error handling, such as 429 exponential back-off, but it is pretty much just a barebone interface to the Proton API. For example, the encryption and decryption of the Proton Drive file are not provided in this library. + +This codebase, Proton API Bridge, bridges the gap, so software like [rclone](https://github.com/rclone/rclone) can be built on top of this quickly. This codebase handles the intricate tasks before and after calling Proton APIs, particularly the complex encryption scheme, allowing developers to implement features for other software on top of this codebase. + +Currently, only Proton Drive APIs are bridged, as we are aiming to implement a backend for rclone. + +## Sidenotes + +We are using a fork of the [proton-go-api](https://github.com/henrybear327/go-proton-api), as we are adding quite some new code to it. We are actively rebasing on top of the master branch of the upstream, as we will try to commit back to the upstream once we feel like the code changes are stable. + +# Unit testing and linting + +`golangci-lint run && go test -race -failfast -v ./...` + +# Drive APIs + +> In collaboration with Azimjon Pulatov, in memory of our good old days at Meta, London, in the summer of 2022. + +Currently, the development are split into 2 versions. +V1 supports the features [required by rclone](https://github.com/henrybear327/rclone/blob/master/fs/types.go), such as `file listing`. As the unit and integration tests from rclone have all been passed, we would stabilize this and then move onto developing V2. +V2 will bring in optimizations and enhancements, such as optimizing uploading and downloading performance, supporting thumbnails, etc. + +## V1 + +### Features + +- [x] Log in to an account without 2FA using username and password +- [x] Obtain keyring +- [x] Cache access token, etc. to be able to reuse the session + - [x] Bug: 403: Access token does not have sufficient scope - used the wrong newClient function +- [x] Volume actions + - [x] List all volumes +- [x] Share actions + - [x] Get all shares + - [x] Get default share +- [x] Fix context with proper propagation instead of using `ctx` everywhere +- [x] Folder actions + - [x] List all folders and files within the root folder + - [x] BUG: listing directory - missing signature when there are more than 1 share -> we need to check for the "active" folder type first + - [x] List all folders and files recursively within the root folder + - [x] Delete + - [x] Create +- [x] File actions + - [x] Download + - [x] Download empty file + - [x] Properly handle large files and empty files (check iOS codebase) + - esp. large files, where buffering in-memory will screw up the runtime + - [x] Check signature and hash + - [x] Delete + - [x] Upload + - [x] Handle empty file + - [x] Parse mime type + - [x] Add revision + - [x] Modified time + - [x] List file metadata +- [x] Duplicated file name handling: 422: A file or folder with that name already exists (Code=2500, Status=422) +- [x] Init ProtonDrive with config passed in as Map +- [x] Remove all `log.Fatalln` and use proper error propagation (basically remove `HandleError` and we go from there) +- [x] Integration tests + - [x] Remove drive demo code + - [x] Create a Drive struct to encapsulate all the functions (maybe?) + - [x] Move comments to proper places + - [x] Modify `shouldRejectDestructiveActions()` + - [x] Refactor +- [x] Reduce config options on caching access token +- [x] Remove integration test safeguarding + +### TODO + +- [x] address go dependencies + - Fixed by doing the following in the `go-proton-api` repo to bump to use the latest commit + - `go get github.com/ProtonMail/go-proton-api@ea8de5f674b7f9b0cca8e3a5076ffe3c5a867e01` + - `go get github.com/ProtonMail/gluon@fb7689b15ae39c3efec3ff3c615c3d2dac41cec8` +- [x] Remove mail-related apis (to reduce dependencies) +- [x] Make a "super class" and expose all necessary methods for the outside to call +- [x] Add 2FA login +- [x] Fix the function argument passing (using pointers) +- [x] Handle account with + - [x] multiple addresses + - [x] multiple keys per addresses +- [x] Update RClone's contribution.md file +- [x] Remove delete all's hardcoded string +- [x] Point to the right proton-go-api branch + - [x] Run `go get github.com/henrybear327/go-proton-api@dev` to update go mod + +### Known limitations + +- Large file handling: for uploading, files will be loaded into the memory entirely, encrypted, and then chunked; for downloading, the file will be written when all blocks are decrypted and checked +- Crypto-related operations, e.g. signature verification, still needs to cross check with iOS or web open source codebase +- No thumbnails, respecting accepted MIME types, max upload size, can't init Proton Drive, etc. +- Assumptions + - only one main share per account + - only operate on active links + +## V2 + +- [ ] Improve file searching function to use HMAC instead of just using string comparison +- [ ] Remove e.g. proton.link related exposures in the function signature (this library should abstract them all) +- [ ] Documentation +- [ ] Go through Drive iOS source code and check the logic control flow +- [ ] Use proper AppVersion (we need to be friendly to the Proton servers) +- [ ] Figure out the bottleneck by doing some profiling +- [ ] Proper error handling by looking at the return code instead of the error string + - [ ] Duplicated folder name handling: 422: A file or folder with that name already exists (Code=2500, Status=422) + - [ ] Not found: ERROR RESTY 422: File or folder was not found. (Code=2501, Status=422), Attempt 1 + - [ ] Failed upload: Draft already exists on this revision (Code=2500, Status=409) +- [ ] File + - [ ] Improve large file handling + - [ ] Handle failed / interrupted upload + - [ ] [Filename encoding](https://github.com/ProtonMail/WebClients/blob/b4eba99d241af4fdae06ff7138bd651a40ef5d3c/applications/drive/src/app/store/_links/validation.ts#L51) +- [ ] Folder + - [ ] (Feature) Update (force overwrite) + - [ ] (Feature) Move +- [ ] Commit back to proton-go-api and switch to using upstream (make sure the tag is at the tip though) +- [ ] Support legacy 2-password mode +- [ ] Support thumbnail +- [ ] Proton Drive init (no prior Proton Drive login before -> probably will have no key, volume, etc. to start with at all) +- [ ] linkID caching -> would need to listen to the event api though +- [ ] Integration tests + - [ ] Check file metadata + - [ ] Try to check if all functions are used at least once so we know if it's functioning or not +- [ ] Handle accounts with multiple shares +- [ ] Use CI to run integration tests +- [ ] Some error handling from [here](https://github.com/ProtonMail/WebClients/blob/main/packages/shared/lib/drive/constants.ts) MAX_NAME_LENGTH, TIMEOUT +- [ ] [Mimetype restrictions](https://github.com/ProtonMail/WebClients/blob/main/packages/shared/lib/drive/constants.ts#LL47C14-L47C42) +- [ ] Address TODO and FIXME + +# Questions + +- [x] rclone's folder / file rename detection? -> just implement the interface and rclone will deal with the rest! +- [ ] How often will we run into 429 on login diff --git a/common/config.go b/common/config.go new file mode 100644 index 0000000..5891c1f --- /dev/null +++ b/common/config.go @@ -0,0 +1,96 @@ +package common + +import "os" + +type Config struct { + /* Login */ + FirstLoginCredential *FirstLoginCredentialData + ReusableCredential *ReusableCredentialData + UseReusableLogin bool + CredentialCacheFile string // If CredentialCacheFile is empty, no credential will be logged + RefreshAccessToken bool + + /* Setting */ + DestructiveIntegrationTest bool // CAUTION: the integration test requires a clean proton drive + EmptyTrashAfterIntegrationTest bool // CAUTION: the integration test will clean up all the data in the trash + + /* Drive */ + DataFolderName string +} + +type FirstLoginCredentialData struct { + Username string + Password string + TwoFA string +} + +type ReusableCredentialData struct { + UID string + AccessToken string + RefreshToken string + SaltedKeyPass string // []byte <-> base64 +} + +func NewConfigWithDefaultValues() *Config { + return &Config{ + // login + FirstLoginCredential: &FirstLoginCredentialData{ + Username: "", + Password: "", + TwoFA: "", + }, + ReusableCredential: &ReusableCredentialData{ + UID: "", + AccessToken: "", + RefreshToken: "", + SaltedKeyPass: "", // []byte <-> base64 + }, + UseReusableLogin: false, + CredentialCacheFile: "", + RefreshAccessToken: false, + + DestructiveIntegrationTest: false, + EmptyTrashAfterIntegrationTest: false, + + DataFolderName: "data", + } +} + +func NewConfigForIntegrationTests() *Config { + username := os.Getenv("PROTON_API_BRIDGE_TEST_USERNAME") + password := os.Getenv("PROTON_API_BRIDGE_TEST_PASSWORD") + twoFA := os.Getenv("PROTON_API_BRIDGE_TEST_TWOFA") + + useReusableLoginStr := os.Getenv("PROTON_API_BRIDGE_TEST_USE_REUSABLE_LOGIN") + useReusableLogin := false + if useReusableLoginStr == "1" { + useReusableLogin = true + } + + uid := os.Getenv("PROTON_API_BRIDGE_TEST_UID") + accessToken := os.Getenv("PROTON_API_BRIDGE_TEST_ACCESS_TOKEN") + refreshToken := os.Getenv("PROTON_API_BRIDGE_TEST_REFRESH_TOKEN") + saltedKeyPass := os.Getenv("PROTON_API_BRIDGE_TEST_SALTEDKEYPASS") + + return &Config{ + FirstLoginCredential: &FirstLoginCredentialData{ + Username: username, + Password: password, + TwoFA: twoFA, + }, + ReusableCredential: &ReusableCredentialData{ + UID: uid, + AccessToken: accessToken, + RefreshToken: refreshToken, + SaltedKeyPass: saltedKeyPass, // []byte <-> base64 + }, + UseReusableLogin: useReusableLogin, + CredentialCacheFile: ".credential", + RefreshAccessToken: false, + + DestructiveIntegrationTest: true, + EmptyTrashAfterIntegrationTest: true, + + DataFolderName: "data", + } +} diff --git a/common/error.go b/common/error.go new file mode 100644 index 0000000..6c3c3a3 --- /dev/null +++ b/common/error.go @@ -0,0 +1,11 @@ +package common + +import "errors" + +var ( + ErrKeyPassOrSaltedKeyPassMustBeNotNil = errors.New("either keyPass or saltedKeyPass must be not nil") + ErrFailedToUnlockUserKeys = errors.New("failed to unlock user keys") + + ErrUsernameAndPasswordRequired = errors.New("username and password are required") + Err2FACodeRequired = errors.New("this account requires a 2FA code") +) diff --git a/common/keyring.go b/common/keyring.go new file mode 100644 index 0000000..e7ecb14 --- /dev/null +++ b/common/keyring.go @@ -0,0 +1,70 @@ +package common + +import ( + "context" + + "github.com/ProtonMail/gopenpgp/v2/crypto" + "github.com/henrybear327/go-proton-api" +) + +/* +The Proton account keys are organized in the following hierarchy. + +An account has some users, each of the user will have one or more user keys. +Each of the user will have some addresses, each of the address will have one or more address keys. + +A key is encrypted by a passphrase, and the passphrase is encrypted by another key. + +The address keyrings are encrypted with the primary user keyring at the time. + +The primary address key is used to create (encrypt) and retrieve (decrypt) data, e.g. shares +*/ +func getAccountKRs(ctx context.Context, c *proton.Client, keyPass, saltedKeyPass []byte) (*crypto.KeyRing, map[string]*crypto.KeyRing, []proton.Address, []byte, error) { + /* Code taken and modified from proton-bridge */ + + user, err := c.GetUser(ctx) + if err != nil { + return nil, nil, nil, nil, err + } + // log.Printf("user %#v", user) + + addr, err := c.GetAddresses(ctx) + if err != nil { + return nil, nil, nil, nil, err + } + // log.Printf("addr %#v", addr) + + if saltedKeyPass == nil { + if keyPass == nil { + return nil, nil, nil, nil, ErrKeyPassOrSaltedKeyPassMustBeNotNil + } + + /* + Notes for -> BUG: Access token does not have sufficient scope + Only within the first x minutes that the user logs in with username and password, the getSalts route will be available to be called! + */ + salts, err := c.GetSalts(ctx) + if err != nil { + return nil, nil, nil, nil, err + } + // log.Printf("salts %#v", salts) + + saltedKeyPass, err = salts.SaltForKey(keyPass, user.Keys.Primary().ID) + if err != nil { + return nil, nil, nil, nil, err + } + // log.Printf("saltedKeyPass ok") + } + + userKR, addrKRs, err := proton.Unlock(user, addr, saltedKeyPass, nil) + if err != nil { + return nil, nil, nil, nil, err + + } else if userKR.CountDecryptionEntities() == 0 { + if err != nil { + return nil, nil, nil, nil, ErrFailedToUnlockUserKeys + } + } + + return userKR, addrKRs, addr, saltedKeyPass, nil +} diff --git a/common/proton_manager.go b/common/proton_manager.go new file mode 100644 index 0000000..0477c0b --- /dev/null +++ b/common/proton_manager.go @@ -0,0 +1,28 @@ +package common + +import ( + "github.com/henrybear327/go-proton-api" +) + +// TODO: use proper appname and version +func AppVersion() string { + // return "web-drive@5.0.13.8" + return "ios-drive@1.14.0" +} + +func defaultAPIOptions() []proton.Option { + return []proton.Option{ + proton.WithAppVersion(AppVersion()), + } +} + +func getProtonManager() *proton.Manager { + /* + Notes on API calls + + If the app version is not specified, the api calls will be rejected. + */ + m := proton.New(defaultAPIOptions()...) + + return m +} diff --git a/common/user.go b/common/user.go new file mode 100644 index 0000000..71cfda4 --- /dev/null +++ b/common/user.go @@ -0,0 +1,156 @@ +package common + +import ( + "context" + "encoding/base64" + "encoding/json" + "log" + "os" + + "github.com/ProtonMail/gopenpgp/v2/crypto" + "github.com/henrybear327/go-proton-api" +) + +func cacheCredentialToFile(config *Config) error { + if config.CredentialCacheFile != "" { + str, err := json.Marshal(config.ReusableCredential) + if err != nil { + return err + } + + file, err := os.Create(config.CredentialCacheFile) + if err != nil { + return err + } + defer file.Close() + _, err = file.WriteString(string(str)) + if err != nil { + return err + } + } + + return nil +} + +/* +Log in methods +- username and password to log in +- UID and refresh token + +Keyring decryption +The password will be salted, and then used to decrypt the keyring. The salted password needs to be and can be cached, so the keyring can be re-decrypted when needed +*/ +func Login(ctx context.Context, config *Config) (*proton.Manager, *proton.Client, *crypto.KeyRing, map[string]*crypto.KeyRing, []proton.Address, error) { + var c *proton.Client + var auth proton.Auth + var userKR *crypto.KeyRing + var addrKRs map[string]*crypto.KeyRing + var addr []proton.Address + + // get manager + m := getProtonManager() + + if config.UseReusableLogin { + /* + Using NewClientWithRefresh so the credential can last longer, + as each run of the program will trigger a access token refresh + */ + var err error + if config.RefreshAccessToken { + c, auth, err = m.NewClientWithRefresh(ctx, config.ReusableCredential.UID, config.ReusableCredential.RefreshToken) + if err != nil { + return nil, nil, nil, nil, nil, err + } + + config.ReusableCredential.UID = auth.UID + config.ReusableCredential.AccessToken = auth.AccessToken + config.ReusableCredential.RefreshToken = auth.RefreshToken + } else { + c = m.NewClient(config.ReusableCredential.UID, config.ReusableCredential.AccessToken, config.ReusableCredential.RefreshToken) + } + + err = cacheCredentialToFile(config) + if err != nil { + return nil, nil, nil, nil, nil, err + } + + SaltedKeyPassByteArr, err := base64.StdEncoding.DecodeString(config.ReusableCredential.SaltedKeyPass) + if err != nil { + return nil, nil, nil, nil, nil, err + } + userKR, addrKRs, addr, _, err = getAccountKRs(ctx, c, nil, SaltedKeyPassByteArr) + if err != nil { + return nil, nil, nil, nil, nil, err + } + } else { + username := config.FirstLoginCredential.Username + password := config.FirstLoginCredential.Password + if username == "" || password == "" { + return nil, nil, nil, nil, nil, ErrUsernameAndPasswordRequired + } + + // perform login + var err error + c, auth, err = m.NewClientWithLogin(ctx, username, []byte(password)) + if err != nil { + return nil, nil, nil, nil, nil, err + } + + if auth.TwoFA.Enabled&proton.HasTOTP != 0 { + if config.FirstLoginCredential.TwoFA != "" { + err := c.Auth2FA(ctx, proton.Auth2FAReq{ + TwoFactorCode: config.FirstLoginCredential.TwoFA, + }) + if err != nil { + return nil, nil, nil, nil, nil, err + } + } else { + return nil, nil, nil, nil, nil, Err2FACodeRequired + } + } + + // decrypt keyring + var saltedKeyPassByteArr []byte + userKR, addrKRs, addr, saltedKeyPassByteArr, err = getAccountKRs(ctx, c, []byte(password), nil) + if err != nil { + return nil, nil, nil, nil, nil, err + } + + saltedKeyPass := base64.StdEncoding.EncodeToString(saltedKeyPassByteArr) + config.ReusableCredential.UID = auth.UID + config.ReusableCredential.AccessToken = auth.AccessToken + config.ReusableCredential.RefreshToken = auth.RefreshToken + config.ReusableCredential.SaltedKeyPass = saltedKeyPass + + err = cacheCredentialToFile(config) + if err != nil { + return nil, nil, nil, nil, nil, err + } + } + + return m, c, userKR, addrKRs, addr, nil +} + +func Logout(ctx context.Context, config *Config, m *proton.Manager, c *proton.Client, userKR *crypto.KeyRing, addrKRs map[string]*crypto.KeyRing) error { + defer m.Close() + defer c.Close() + + if config.CredentialCacheFile == "" { + log.Println("Logging out user") + + // log out + err := c.AuthDelete(ctx) + if err != nil { + return err + } + + // clear keyrings + userKR.ClearPrivateParams() + + for i := range addrKRs { + addrKRs[i].ClearPrivateParams() + } + } + + return nil +} diff --git a/constants.go b/constants.go new file mode 100644 index 0000000..e67d2e1 --- /dev/null +++ b/constants.go @@ -0,0 +1,5 @@ +package proton_api_bridge + +var ( + UPLOAD_BLOCK_SIZE = 4 * 1024 * 1024 +) diff --git a/crypto.go b/crypto.go new file mode 100644 index 0000000..b188be4 --- /dev/null +++ b/crypto.go @@ -0,0 +1,168 @@ +package proton_api_bridge + +import ( + "crypto/sha256" + "encoding/base64" + "io" + + "github.com/ProtonMail/gopenpgp/v2/crypto" + "github.com/ProtonMail/gopenpgp/v2/helper" +) + +func generatePassphrase() (string, error) { + token, err := crypto.RandomToken(32) + if err != nil { + return "", err + } + + tokenBase64 := base64.StdEncoding.EncodeToString(token) + return tokenBase64, nil +} + +func generateCryptoKey() (string, string, error) { + passphrase, err := generatePassphrase() + if err != nil { + return "", "", err + } + + // all hardcoded values from iOS drive + key, err := helper.GenerateKey("Drive key", "noreply@protonmail.com", []byte(passphrase), "x25519", 0) + if err != nil { + return "", "", err + } + + return passphrase, key, nil +} + +// taken from Proton Go API Backend +func encryptWithSignature(kr, addrKR *crypto.KeyRing, b []byte) (string, string, error) { + enc, err := kr.Encrypt(crypto.NewPlainMessage(b), nil) + if err != nil { + return "", "", err + } + + encArm, err := enc.GetArmored() + if err != nil { + return "", "", err + } + + sig, err := addrKR.SignDetached(crypto.NewPlainMessage(b)) + if err != nil { + return "", "", err + } + + sigArm, err := sig.GetArmored() + if err != nil { + return "", "", err + } + + return encArm, sigArm, nil +} + +func generateNodeKeys(kr, addrKR *crypto.KeyRing) (string, string, string, error) { + nodePassphrase, nodeKey, err := generateCryptoKey() + if err != nil { + return "", "", "", err + } + + nodePassphraseEnc, nodePassphraseSignature, err := encryptWithSignature(kr, addrKR, []byte(nodePassphrase)) + if err != nil { + return "", "", "", err + } + + return nodeKey, nodePassphraseEnc, nodePassphraseSignature, nil +} + +func reencryptKeyPacket(srcKR, dstKR, addrKR *crypto.KeyRing, passphrase string) (string, error) { + oldSplitMessage, err := crypto.NewPGPSplitMessageFromArmored(passphrase) + if err != nil { + return "", err + } + + sessionKey, err := srcKR.DecryptSessionKey(oldSplitMessage.KeyPacket) + if err != nil { + return "", err + } + + newKeyPacket, err := dstKR.EncryptSessionKey(sessionKey) + if err != nil { + return "", err + } + + newSplitMessage := crypto.NewPGPSplitMessage(newKeyPacket, oldSplitMessage.DataPacket) + + return newSplitMessage.GetArmored() +} + +func getKeyRing(kr, addrKR *crypto.KeyRing, key, passphrase, passphraseSignature string) (*crypto.KeyRing, error) { + enc, err := crypto.NewPGPMessageFromArmored(passphrase) + if err != nil { + return nil, err + } + + dec, err := kr.Decrypt(enc, nil, crypto.GetUnixTime()) + if err != nil { + return nil, err + } + + sig, err := crypto.NewPGPSignatureFromArmored(passphraseSignature) + if err != nil { + return nil, err + } + + if err := addrKR.VerifyDetached(dec, sig, crypto.GetUnixTime()); err != nil { + return nil, err + } + + lockedKey, err := crypto.NewKeyFromArmored(key) + if err != nil { + return nil, err + } + + unlockedKey, err := lockedKey.Unlock(dec.GetBinary()) + if err != nil { + return nil, err + } + + return crypto.NewKeyRing(unlockedKey) +} + +func decryptBlockIntoBuffer(sessionKey *crypto.SessionKey, addrKR, nodeKR *crypto.KeyRing, originalHash, encSignature string, buffer io.ReaderFrom, block io.ReadCloser) error { + data, err := io.ReadAll(block) + if err != nil { + return err + } + + plainMessage, err := sessionKey.Decrypt(data) + if err != nil { + return err + } + + encSignatureArm, err := crypto.NewPGPMessageFromArmored(encSignature) + if err != nil { + return err + } + + err = addrKR.VerifyDetachedEncrypted(plainMessage, encSignatureArm, nodeKR, crypto.GetUnixTime()) + if err != nil { + return err + } + + _, err = buffer.ReadFrom(plainMessage.NewReader()) + if err != nil { + return err + } + + h := sha256.New() + h.Write(data) + hash := h.Sum(nil) + base64Hash := base64.StdEncoding.EncodeToString(hash) + if err != nil { + return err + } + if base64Hash != originalHash { + return ErrDownloadedBlockHashVerificationFailed + } + + return nil +} diff --git a/delete.go b/delete.go new file mode 100644 index 0000000..4115d7e --- /dev/null +++ b/delete.go @@ -0,0 +1,101 @@ +package proton_api_bridge + +import ( + "context" + + "github.com/henrybear327/go-proton-api" +) + +func (protonDrive *ProtonDrive) moveToTrash(ctx context.Context, parentLinkID string, linkIDs ...string) error { + err := protonDrive.c.TrashChildren(ctx, protonDrive.MainShare.ShareID, parentLinkID, linkIDs...) + if err != nil { + return err + } + + return nil +} + +func (protonDrive *ProtonDrive) MoveFileToTrashByID(ctx context.Context, linkID string) error { + fileLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, linkID) + if err != nil { + return err + } + if fileLink.Type != proton.LinkTypeFile { + return ErrLinkTypeMustToBeFolderType + } + + return protonDrive.moveToTrash(ctx, fileLink.ParentLinkID, linkID) +} + +func (protonDrive *ProtonDrive) MoveFolderToTrashByID(ctx context.Context, linkID string, onlyOnEmpty bool) error { + folderLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, linkID) + if err != nil { + return err + } + if folderLink.Type != proton.LinkTypeFolder { + return ErrLinkTypeMustToBeFolderType + } + + childrenLinks, err := protonDrive.c.ListChildren(ctx, protonDrive.MainShare.ShareID, linkID, false) + if err != nil { + return err + } + + if onlyOnEmpty { + if len(childrenLinks) > 0 { + return ErrFolderIsNotEmpty + } + } + + return protonDrive.moveToTrash(ctx, folderLink.ParentLinkID, linkID) +} + +// WARNING!!!! +// Everything in the root folder will be moved to trash +// Most likely only used for debugging when the key is messed up +func (protonDrive *ProtonDrive) EmptyRootFolder(ctx context.Context) error { + links, err := protonDrive.c.ListChildren(ctx, protonDrive.MainShare.ShareID, protonDrive.MainShare.LinkID, true) + if err != nil { + return err + } + + { + linkIDs := make([]string, 0) + for i := range links { + if links[i].State == proton.LinkStateActive /* use TrashChildren */ { + linkIDs = append(linkIDs, links[i].LinkID) + } + } + + err := protonDrive.c.TrashChildren(ctx, protonDrive.MainShare.ShareID, protonDrive.MainShare.LinkID, linkIDs...) + if err != nil { + return err + } + } + + { + linkIDs := make([]string, 0) + for i := range links { + if links[i].State != proton.LinkStateActive { + linkIDs = append(linkIDs, links[i].LinkID) + } + } + + err := protonDrive.c.DeleteChildren(ctx, protonDrive.MainShare.ShareID, protonDrive.MainShare.LinkID, linkIDs...) + if err != nil { + return err + } + } + + return nil +} + +// Empty the trash +func (protonDrive *ProtonDrive) EmptyTrash(ctx context.Context) error { + err := protonDrive.c.EmptyTrash(ctx, protonDrive.MainShare.ShareID) + if err != nil { + return err + } + + return nil +} diff --git a/drive.go b/drive.go new file mode 100644 index 0000000..15338c3 --- /dev/null +++ b/drive.go @@ -0,0 +1,162 @@ +package proton_api_bridge + +import ( + "context" + "log" + + "github.com/henrybear327/Proton-API-Bridge/common" + + "github.com/ProtonMail/gopenpgp/v2/crypto" + "github.com/henrybear327/go-proton-api" +) + +type ProtonDrive struct { + MainShare *proton.Share + RootLink *proton.Link + + MainShareKR *crypto.KeyRing + AddrKR *crypto.KeyRing + + Config *common.Config + + c *proton.Client + m *proton.Manager + userKR *crypto.KeyRing + addrKRs map[string]*crypto.KeyRing + addrData []proton.Address + signatureAddress string +} + +func NewDefaultConfig() *common.Config { + return common.NewConfigWithDefaultValues() +} + +func NewProtonDrive(ctx context.Context, config *common.Config) (*ProtonDrive, error) { + /* Log in and logout */ + m, c, userKR, addrKRs, addrData, err := common.Login(ctx, config) + if err != nil { + return nil, err + } + + /* + Current understanding (at the time of the commit) + + The volume is the mount point. + + A link is like a folder in POSIX. + + A share is associated with a link to represent the access control, + and serves as an entry point to a location in the file structure (Volume). + It points to a link, of file or folder type, anywhere in the tree and holds a key called the ShareKey. + To access a link, of file or folder type, a user must be a member of a share. + + A volume has a default share for access control and is owned by the creator of the volume. + A volume has a default link as it's root folder. + + MIMETYPE holds type, e.g. folder, image/png, etc. + */ + volumes, err := listAllVolumes(ctx, c) + if err != nil { + return nil, err + } + // log.Printf("all volumes %#v", volumes) + + mainShareID := "" + for i := range volumes { + // iOS drive: first active volume + if volumes[i].State == proton.VolumeStateActive { + mainShareID = volumes[i].Share.ShareID + } + } + // log.Println("total volumes", len(volumes), "mainShareID", mainShareID) + + /* Get root folder from the main share of the volume */ + mainShare, err := getShareByID(ctx, c, mainShareID) + if err != nil { + return nil, err + } + + // check for main share integrity + { + mainShareCheck := false + shares, err := getAllShares(ctx, c) + if err != nil { + return nil, err + } + for i := range shares { + if shares[i].ShareID == mainShare.ShareID && + shares[i].LinkID == mainShare.LinkID && + shares[i].Flags == proton.PrimaryShare && + shares[i].Type == proton.ShareTypeMain { + mainShareCheck = true + } + } + + if !mainShareCheck { + log.Printf("mainShare %#v", mainShare) + log.Printf("shares %#v", shares) + return nil, ErrMainSharePreconditionsFailed + } + } + + // Note: rootLink's parentLinkID == "" + /* + Link holds the tree structure, for the clients, they represent the files and folders of a given volume. + They have a ParentLinkID that points to parent folders. + Links also hold the file name (encrypted) and a hash of the name for name collisions. + Link data is encrypted with its owning Share keyring. + */ + rootLink, err := c.GetLink(ctx, mainShare.ShareID, mainShare.LinkID) + if err != nil { + return nil, err + } + if err != nil { + return nil, err + } + // log.Printf("rootLink %#v", rootLink) + + // log.Printf("addrKRs %#v", addrKRs)= + addrKR := addrKRs[mainShare.AddressID] + // log.Println("addrKR CountDecryptionEntities", addrKR.CountDecryptionEntities()) + + mainShareKR, err := mainShare.GetKeyRing(addrKR) + if err != nil { + return nil, err + } + // log.Println("mainShareKR CountDecryptionEntities", mainShareKR.CountDecryptionEntities()) + + return &ProtonDrive{ + MainShare: mainShare, + RootLink: &rootLink, + + MainShareKR: mainShareKR, + AddrKR: addrKR, + + Config: config, + + c: c, + m: m, + userKR: userKR, + addrKRs: addrKRs, + addrData: addrData, + signatureAddress: mainShare.Creator, + }, nil +} + +func (protonDrive *ProtonDrive) Logout(ctx context.Context) error { + return common.Logout(ctx, protonDrive.Config, protonDrive.m, protonDrive.c, protonDrive.userKR, protonDrive.addrKRs) +} + +func (protonDrive *ProtonDrive) About(ctx context.Context) (*proton.User, error) { + user, err := protonDrive.c.GetUser(ctx) + if err != nil { + return nil, err + } + + return &user, nil +} + +func (protonDrive *ProtonDrive) GetLink(ctx context.Context, linkID string) (*proton.Link, error) { + link, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, linkID) + return &link, err +} diff --git a/drive_test.go b/drive_test.go new file mode 100644 index 0000000..cd2ad71 --- /dev/null +++ b/drive_test.go @@ -0,0 +1,288 @@ +package proton_api_bridge + +import ( + "context" + "log" + "strings" + "testing" + + "github.com/henrybear327/Proton-API-Bridge/common" + "github.com/henrybear327/Proton-API-Bridge/utility" +) + +func setup(t *testing.T) (context.Context, context.CancelFunc, *ProtonDrive) { + utility.SetupLog() + + config := common.NewConfigForIntegrationTests() + + { + // pre-condition check + if !config.DestructiveIntegrationTest { + t.Fatalf("CAUTION: the integration test requires a clean proton drive") + } + if !config.EmptyTrashAfterIntegrationTest { + t.Fatalf("CAUTION: the integration test requires cleaning up the drive after running the tests") + } + } + + ctx, cancel := context.WithCancel(context.Background()) + + protonDrive, err := NewProtonDrive(ctx, config) + if err != nil { + t.Fatal(err) + } + + err = protonDrive.EmptyRootFolder(ctx) + if err != nil { + t.Fatal(err) + } + + err = protonDrive.EmptyTrash(ctx) + if err != nil { + t.Fatal(err) + } + + return ctx, cancel, protonDrive +} + +func tearDown(t *testing.T, ctx context.Context, protonDrive *ProtonDrive) { + if protonDrive.Config.EmptyTrashAfterIntegrationTest { + err := protonDrive.EmptyTrash(ctx) + if err != nil { + t.Fatal(err) + } + } +} + +/* Integration Tests */ +func TestCreateAndDeleteFolder(t *testing.T) { + ctx, cancel, protonDrive := setup(t) + t.Cleanup(func() { + defer cancel() + defer tearDown(t, ctx, protonDrive) + }) + + log.Println("Create a folder tmp at root") + createFolder(t, ctx, protonDrive, "", "tmp") + checkFileListing(t, ctx, protonDrive, []string{"/tmp"}) + + log.Println("Delet folder tmp") + deleteBySearchingFromRoot(t, ctx, protonDrive, "tmp", true) + checkFileListing(t, ctx, protonDrive, []string{}) +} + +func TestUploadAndDownloadAndDeleteAFile(t *testing.T) { + ctx, cancel, protonDrive := setup(t) + t.Cleanup(func() { + defer cancel() + defer tearDown(t, ctx, protonDrive) + }) + + log.Println("Upload integrationTestImage.png") + uploadFileByFilepath(t, ctx, protonDrive, "", "integrationTestImage.png", "testcase/integrationTestImage.png") + checkRevisions(protonDrive, ctx, t, "integrationTestImage.png", 1) + checkFileListing(t, ctx, protonDrive, []string{"/integrationTestImage.png"}) + downloadFile(t, ctx, protonDrive, "", "integrationTestImage.png", "testcase/integrationTestImage.png", "") + + log.Println("Upload a new revision to replace integrationTestImage.png") + uploadFileByFilepath(t, ctx, protonDrive, "", "integrationTestImage.png", "testcase/integrationTestImage2.png") /* Add a revision */ + checkRevisions(protonDrive, ctx, t, "integrationTestImage.png", 2) + downloadFile(t, ctx, protonDrive, "", "integrationTestImage.png", "testcase/integrationTestImage2.png", "") + checkFileListing(t, ctx, protonDrive, []string{"/integrationTestImage.png"}) + + log.Println("Delete file integrationTestImage.png") + deleteBySearchingFromRoot(t, ctx, protonDrive, "integrationTestImage.png", false) + checkFileListing(t, ctx, protonDrive, []string{}) +} + +func TestUploadAndDeleteAnEmptyFileAtRoot(t *testing.T) { + ctx, cancel, protonDrive := setup(t) + t.Cleanup(func() { + defer cancel() + defer tearDown(t, ctx, protonDrive) + }) + + log.Println("Upload empty.txt") + uploadFileByFilepath(t, ctx, protonDrive, "", "empty.txt", "testcase/empty.txt") + checkRevisions(protonDrive, ctx, t, "empty.txt", 1) + checkFileListing(t, ctx, protonDrive, []string{"/empty.txt"}) + downloadFile(t, ctx, protonDrive, "", "empty.txt", "testcase/empty.txt", "") + + log.Println("Upload a new revision to replace empty.txt") + uploadFileByFilepath(t, ctx, protonDrive, "", "empty.txt", "testcase/empty.txt") /* Add a revision */ + checkRevisions(protonDrive, ctx, t, "empty.txt", 2) + downloadFile(t, ctx, protonDrive, "", "empty.txt", "testcase/empty.txt", "") + checkFileListing(t, ctx, protonDrive, []string{"/empty.txt"}) + + log.Println("Delete file empty.txt") + deleteBySearchingFromRoot(t, ctx, protonDrive, "empty.txt", false) + checkFileListing(t, ctx, protonDrive, []string{}) +} + +func TestUploadAndDownloadAndDeleteAFileAtAFolderOneLevelFromRoot(t *testing.T) { + ctx, cancel, protonDrive := setup(t) + t.Cleanup(func() { + defer cancel() + defer tearDown(t, ctx, protonDrive) + }) + + log.Println("Create folder level1") + createFolder(t, ctx, protonDrive, "", "level1") + checkFileListing(t, ctx, protonDrive, []string{"/level1"}) + + log.Println("Upload integrationTestImage.png to level1") + uploadFileByFilepath(t, ctx, protonDrive, "level1", "integrationTestImage.png", "testcase/integrationTestImage.png") + checkRevisions(protonDrive, ctx, t, "integrationTestImage.png", 1) + checkFileListing(t, ctx, protonDrive, []string{"/level1", "/level1/integrationTestImage.png"}) + downloadFile(t, ctx, protonDrive, "level1", "integrationTestImage.png", "testcase/integrationTestImage.png", "") + + log.Println("Upload a new revision to replace integrationTestImage.png in level1") + uploadFileByFilepath(t, ctx, protonDrive, "level1", "integrationTestImage.png", "testcase/integrationTestImage2.png") /* Add a revision */ + checkRevisions(protonDrive, ctx, t, "integrationTestImage.png", 2) + downloadFile(t, ctx, protonDrive, "level1", "integrationTestImage.png", "testcase/integrationTestImage2.png", "") + + log.Println("Delete folder level1") + deleteBySearchingFromRoot(t, ctx, protonDrive, "level1", true) + checkFileListing(t, ctx, protonDrive, []string{}) +} + +func TestCreateAndMoveAndDeleteFolder(t *testing.T) { + ctx, cancel, protonDrive := setup(t) + t.Cleanup(func() { + defer cancel() + defer tearDown(t, ctx, protonDrive) + }) + + log.Println("Create a folder src at root") + createFolder(t, ctx, protonDrive, "", "src") + checkFileListing(t, ctx, protonDrive, []string{"/src"}) + + log.Println("Create a folder dst at root") + createFolder(t, ctx, protonDrive, "", "dst") + checkFileListing(t, ctx, protonDrive, []string{"/src", "/dst"}) + + log.Println("Move folder src to under folder dst") + moveFolder(t, ctx, protonDrive, "src", "dst") + checkFileListing(t, ctx, protonDrive, []string{"/dst", "/dst/src"}) + + log.Println("Delete folder dst") + deleteBySearchingFromRoot(t, ctx, protonDrive, "dst", true) + checkFileListing(t, ctx, protonDrive, []string{}) +} + +func TestCreateAndMoveAndDeleteFolderWithAFile(t *testing.T) { + ctx, cancel, protonDrive := setup(t) + t.Cleanup(func() { + defer cancel() + defer tearDown(t, ctx, protonDrive) + }) + + log.Println("Create a folder src at root") + createFolder(t, ctx, protonDrive, "", "src") + checkFileListing(t, ctx, protonDrive, []string{"/src"}) + + log.Println("Upload integrationTestImage.png to src") + uploadFileByFilepath(t, ctx, protonDrive, "src", "integrationTestImage.png", "testcase/integrationTestImage.png") + checkRevisions(protonDrive, ctx, t, "integrationTestImage.png", 1) + checkFileListing(t, ctx, protonDrive, []string{"/src", "/src/integrationTestImage.png"}) + downloadFile(t, ctx, protonDrive, "src", "integrationTestImage.png", "testcase/integrationTestImage.png", "") + + log.Println("Create a folder dst at root") + createFolder(t, ctx, protonDrive, "", "dst") + checkFileListing(t, ctx, protonDrive, []string{"/src", "/src/integrationTestImage.png", "/dst"}) + + log.Println("Upload a new revision to replace integrationTestImage.png in src") + uploadFileByFilepath(t, ctx, protonDrive, "src", "integrationTestImage.png", "testcase/integrationTestImage2.png") /* Add a revision */ + checkRevisions(protonDrive, ctx, t, "integrationTestImage.png", 2) + downloadFile(t, ctx, protonDrive, "src", "integrationTestImage.png", "testcase/integrationTestImage2.png", "") + checkFileListing(t, ctx, protonDrive, []string{"/src", "/src/integrationTestImage.png", "/dst"}) + + log.Println("Move folder src to under folder dst") + moveFolder(t, ctx, protonDrive, "src", "dst") + checkFileListing(t, ctx, protonDrive, []string{"/dst", "/dst/src", "/dst/src/integrationTestImage.png"}) + + log.Println("Delete folder dst") + deleteBySearchingFromRoot(t, ctx, protonDrive, "dst", true) + checkFileListing(t, ctx, protonDrive, []string{}) +} + +func TestCreateAndMoveAndDeleteAFileOneLevelFromRoot(t *testing.T) { + ctx, cancel, protonDrive := setup(t) + t.Cleanup(func() { + defer cancel() + defer tearDown(t, ctx, protonDrive) + }) + + log.Println("Create a folder src at root") + createFolder(t, ctx, protonDrive, "", "src") + checkFileListing(t, ctx, protonDrive, []string{"/src"}) + + log.Println("Upload integrationTestImage.png to src") + uploadFileByFilepath(t, ctx, protonDrive, "src", "integrationTestImage.png", "testcase/integrationTestImage.png") + checkRevisions(protonDrive, ctx, t, "integrationTestImage.png", 1) + checkFileListing(t, ctx, protonDrive, []string{"/src", "/src/integrationTestImage.png"}) + downloadFile(t, ctx, protonDrive, "src", "integrationTestImage.png", "testcase/integrationTestImage.png", "") + + log.Println("Create a folder dst at root") + createFolder(t, ctx, protonDrive, "", "dst") + checkFileListing(t, ctx, protonDrive, []string{"/src", "/src/integrationTestImage.png", "/dst"}) + + log.Println("Upload a new revision to replace integrationTestImage.png in src") + uploadFileByFilepath(t, ctx, protonDrive, "src", "integrationTestImage.png", "testcase/integrationTestImage2.png") /* Add a revision */ + checkRevisions(protonDrive, ctx, t, "integrationTestImage.png", 2) + downloadFile(t, ctx, protonDrive, "src", "integrationTestImage.png", "testcase/integrationTestImage2.png", "") + checkFileListing(t, ctx, protonDrive, []string{"/src", "/src/integrationTestImage.png", "/dst"}) + + log.Println("Move file integrationTestImage.png to under folder dst") + moveFile(t, ctx, protonDrive, "integrationTestImage.png", "dst") + checkFileListing(t, ctx, protonDrive, []string{"/src", "/dst", "/dst/integrationTestImage.png"}) + + log.Println("Delete folder dst") + deleteBySearchingFromRoot(t, ctx, protonDrive, "dst", true) + checkFileListing(t, ctx, protonDrive, []string{"/src"}) + + log.Println("Delete folder src") + deleteBySearchingFromRoot(t, ctx, protonDrive, "src", true) + checkFileListing(t, ctx, protonDrive, []string{}) +} + +func TestUploadLargeNumberOfBlocks(t *testing.T) { + ctx, cancel, protonDrive := setup(t) + t.Cleanup(func() { + defer cancel() + defer tearDown(t, ctx, protonDrive) + }) + + // in order to simulate uploading large files + // we use 1KB for the UPLOAD_BLOCK_SIZE + // so a 1000KB file will generate 1000 blocks to test the uploading mechanism + // and also testing the downloading mechanism + ORIGINAL_UPLOAD_BLOCK_SIZE := UPLOAD_BLOCK_SIZE + defer func() { + UPLOAD_BLOCK_SIZE = ORIGINAL_UPLOAD_BLOCK_SIZE + }() + blocks := 100 + UPLOAD_BLOCK_SIZE = 10 + + filename := "fileContent.txt" + file1Content := RandomString(UPLOAD_BLOCK_SIZE * blocks) + file1ContentReader := strings.NewReader(file1Content) + file2Content := RandomString(UPLOAD_BLOCK_SIZE * blocks) + file2ContentReader := strings.NewReader(file2Content) + + log.Println("Upload fileContent.txt") + uploadFileByReader(t, ctx, protonDrive, "", filename, file1ContentReader) + checkRevisions(protonDrive, ctx, t, filename, 1) + checkFileListing(t, ctx, protonDrive, []string{"/" + filename}) + downloadFile(t, ctx, protonDrive, "", filename, "", file1Content) + + log.Println("Upload a new revision to replace fileContent.txt") + uploadFileByReader(t, ctx, protonDrive, "", filename, file2ContentReader) + checkRevisions(protonDrive, ctx, t, filename, 2) + checkFileListing(t, ctx, protonDrive, []string{"/" + filename}) + downloadFile(t, ctx, protonDrive, "", filename, "", file2Content) + + log.Println("Delete file fileContent.txt") + deleteBySearchingFromRoot(t, ctx, protonDrive, filename, false) + checkFileListing(t, ctx, protonDrive, []string{}) +} diff --git a/drive_test_helper.go b/drive_test_helper.go new file mode 100644 index 0000000..0495fba --- /dev/null +++ b/drive_test_helper.go @@ -0,0 +1,308 @@ +package proton_api_bridge + +import ( + "bufio" + "bytes" + "context" + "io" + "os" + "testing" + "time" + + "github.com/henrybear327/go-proton-api" + + mathrand "math/rand" +) + +// Taken from: https://github.com/rclone/rclone/blob/e43b5ce5e59b5717a9819ff81805dd431f710c10/lib/random/random.go +// +// StringFn create a random string for test purposes using the random +// number generator function passed in. +// +// Do not use these for passwords. +func StringFn(n int, randIntn func(n int) int) string { + const ( + vowel = "aeiou" + consonant = "bcdfghjklmnpqrstvwxyz" + digit = "0123456789" + ) + pattern := []string{consonant, vowel, consonant, vowel, consonant, vowel, consonant, digit} + out := make([]byte, n) + p := 0 + for i := range out { + source := pattern[p] + p = (p + 1) % len(pattern) + out[i] = source[randIntn(len(source))] + } + return string(out) +} + +// String create a random string for test purposes. +// +// Do not use these for passwords. +func RandomString(n int) string { + return StringFn(n, mathrand.Intn) +} + +/* Helper functions */ + +func createFolder(t *testing.T, ctx context.Context, protonDrive *ProtonDrive, parent, name string) { + parentLink := protonDrive.RootLink + if parent != "" { + targetFolderLink, err := protonDrive.SearchByNameRecursivelyFromRoot(ctx, parent, true) + if err != nil { + t.Fatal(err) + } + if targetFolderLink == nil { + t.Fatalf("Folder %v not found", parent) + } + parentLink = targetFolderLink + } + if parentLink.Type != proton.LinkTypeFolder { + t.Fatalf("parentLink is not of folder type") + } + + _, err := protonDrive.CreateNewFolderByID(ctx, parentLink.LinkID, name) + if err != nil { + t.Fatal(err) + } +} + +func uploadFileByReader(t *testing.T, ctx context.Context, protonDrive *ProtonDrive, parent, name string, in io.Reader) { + parentLink := protonDrive.RootLink + if parent != "" { + targetFolderLink, err := protonDrive.SearchByNameRecursivelyFromRoot(ctx, parent, true) + if err != nil { + t.Fatal(err) + } + if targetFolderLink == nil { + t.Fatalf("Folder %v not found", parent) + } + parentLink = targetFolderLink + } + if parentLink.Type != proton.LinkTypeFolder { + t.Fatalf("parentLink is not of folder type") + } + + _, _, err := protonDrive.UploadFileByReader(ctx, parentLink.LinkID, name, time.Now(), in) + if err != nil { + t.Fatal(err) + } +} + +func uploadFileByFilepath(t *testing.T, ctx context.Context, protonDrive *ProtonDrive, parent, name string, filepath string) { + parentLink := protonDrive.RootLink + if parent != "" { + targetFolderLink, err := protonDrive.SearchByNameRecursivelyFromRoot(ctx, parent, true) + if err != nil { + t.Fatal(err) + } + if targetFolderLink == nil { + t.Fatalf("Folder %v not found", parent) + } + parentLink = targetFolderLink + } + if parentLink.Type != proton.LinkTypeFolder { + t.Fatalf("parentLink is not of folder type") + } + + f, err := os.Open(filepath) + if err != nil { + t.Fatal(err) + } + defer f.Close() + + info, err := os.Stat(filepath) + if err != nil { + t.Fatal(err) + } + + in := bufio.NewReader(f) + + _, _, err = protonDrive.UploadFileByReader(ctx, parentLink.LinkID, name, info.ModTime(), in) + if err != nil { + t.Fatal(err) + } +} + +func downloadFile(t *testing.T, ctx context.Context, protonDrive *ProtonDrive, parent, name string, filepath string, data string) { + parentLink := protonDrive.RootLink + if parent != "" { + targetFolderLink, err := protonDrive.SearchByNameRecursivelyFromRoot(ctx, parent, true) + if err != nil { + t.Fatal(err) + } + if targetFolderLink == nil { + t.Fatalf("Folder %v not found", parent) + } + + parentLink = targetFolderLink + } + if parentLink.Type != proton.LinkTypeFolder { + t.Fatalf("parentLink is not of folder type") + } + + targetFileLink, err := protonDrive.SearchByNameRecursivelyFromRoot(ctx, name, false) + if err != nil { + t.Fatal(err) + } + if targetFileLink == nil { + t.Fatalf("File %v not found", name) + } else { + downloadedData, fileSystemAttr, err := protonDrive.DownloadFileByID(ctx, targetFileLink.LinkID) + if err != nil { + t.Fatal(err) + } + + /* Check file metadata */ + if fileSystemAttr == nil { + t.Fatalf("FileSystemAttr should not be nil") + } else { + if len(downloadedData) != int(fileSystemAttr.Size) { + t.Fatalf("Downloaded file size != uploaded file size: %#v vs %#v", len(downloadedData), int(fileSystemAttr.Size)) + } + } + + if filepath != "" { + originalData, err := os.ReadFile(filepath) + if err != nil { + t.Fatal(err) + } + + if !bytes.Equal(downloadedData, originalData) { + t.Fatalf("Downloaded content is different from the original content") + } + } else if data != "" { + if !bytes.Equal(downloadedData, []byte(data)) { + t.Fatalf("Downloaded content is different from the original content") + } + } else { + t.Fatalf("Nothing to verify against") + } + } +} + +func checkRevisions(protonDrive *ProtonDrive, ctx context.Context, t *testing.T, name string, totalRevisions int) { + targetFileLink, err := protonDrive.SearchByNameRecursivelyFromRoot(ctx, name, false) + if err != nil { + t.Fatal(err) + } + if targetFileLink == nil { + t.Fatalf("File %v not found", name) + } else { + revisions, err := protonDrive.c.ListRevisions(ctx, protonDrive.MainShare.ShareID, targetFileLink.LinkID) + if err != nil { + t.Fatal(err) + } + + if len(revisions) != totalRevisions { + t.Fatalf("Missing revision") + } + } +} + +// During the integration test, the name much be unique since the link is returned by recursively search for the name from root +func deleteBySearchingFromRoot(t *testing.T, ctx context.Context, protonDrive *ProtonDrive, name string, isFolder bool) { + targetLink, err := protonDrive.SearchByNameRecursivelyFromRoot(ctx, name, isFolder) + if err != nil { + t.Fatal(err) + } + if targetLink == nil { + t.Fatalf("Target %v to be deleted not found", name) + } else { + if isFolder { + err = protonDrive.MoveFolderToTrashByID(ctx, targetLink.LinkID, false) + if err != nil { + t.Fatal(err) + } + } else { + err = protonDrive.MoveFileToTrashByID(ctx, targetLink.LinkID) + if err != nil { + t.Fatal(err) + } + } + } +} + +func checkFileListing(t *testing.T, ctx context.Context, protonDrive *ProtonDrive, expectedPaths []string) { + { + paths := make([]string, 0) + err := protonDrive.ListDirectoriesRecursively(ctx, protonDrive.MainShareKR, protonDrive.RootLink, false, -1, 0, true, "", &paths) + if err != nil { + t.Fatal(err) + } + + if len(paths) != len(expectedPaths) { + t.Fatalf("Total path returned is differs from expected\nReturned %#v\nExpected: %#v\n", paths, expectedPaths) + } + + for i := range paths { + if paths[i] != expectedPaths[i] { + t.Fatalf("The path returned is differs from the path expected\nReturned %#v\nExpected: %#v\n", paths, expectedPaths) + } + } + } + + { + paths := make([]string, 0) + err := protonDrive.ListDirectoriesRecursively(ctx, protonDrive.MainShareKR, protonDrive.RootLink, false, -1, 0, false, "", &paths) + if err != nil { + t.Fatal(err) + } + + // transform + newExpectedPath := make([]string, 0) + newExpectedPath = append(newExpectedPath, "/root") + for i := range expectedPaths { + newExpectedPath = append(newExpectedPath, "/root"+expectedPaths[i]) + } + + if len(paths) != len(newExpectedPath) { + t.Fatalf("Total path returned is differs from expected\nReturned %#v\nExpected: %#v\n", paths, newExpectedPath) + } + + for i := range paths { + if paths[i] != newExpectedPath[i] { + t.Fatalf("The path returned is differs from the path expected\nReturned %#v\nExpected: %#v\n", paths, newExpectedPath) + } + } + } +} + +func moveFolder(t *testing.T, ctx context.Context, protonDrive *ProtonDrive, srcFolderName, dstParentFolderName string) { + targetSrcFolderLink, err := protonDrive.SearchByNameRecursivelyFromRoot(ctx, srcFolderName, true) + if err != nil { + t.Fatal(err) + } + targetDestFolderLink, err := protonDrive.SearchByNameRecursivelyFromRoot(ctx, dstParentFolderName, true) + if err != nil { + t.Fatal(err) + } + if targetSrcFolderLink == nil || targetDestFolderLink == nil { + t.Fatalf("Folder %s or %s found", srcFolderName, dstParentFolderName) + } else { + err := protonDrive.MoveFolder(ctx, targetSrcFolderLink, targetDestFolderLink, srcFolderName) + if err != nil { + t.Fatal(err) + } + } +} + +func moveFile(t *testing.T, ctx context.Context, protonDrive *ProtonDrive, srcFileName, dstParentFolderName string) { + targetSrcFileLink, err := protonDrive.SearchByNameRecursivelyFromRoot(ctx, srcFileName, false) + if err != nil { + t.Fatal(err) + } + targetDestFolderLink, err := protonDrive.SearchByNameRecursivelyFromRoot(ctx, dstParentFolderName, true) + if err != nil { + t.Fatal(err) + } + if targetSrcFileLink == nil || targetDestFolderLink == nil { + t.Fatalf("File %s or folder %s found", srcFileName, dstParentFolderName) + } else { + err := protonDrive.MoveFile(ctx, targetSrcFileLink, targetDestFolderLink, srcFileName) + if err != nil { + t.Fatal(err) + } + } +} diff --git a/error.go b/error.go new file mode 100644 index 0000000..2a7f64e --- /dev/null +++ b/error.go @@ -0,0 +1,16 @@ +package proton_api_bridge + +import "errors" + +var ( + ErrMainSharePreconditionsFailed = errors.New("the main share assumption has failed") + ErrDataFolderNameIsEmpty = errors.New("please supply a DataFolderName to enabling file downloading") + ErrLinkTypeMustToBeFolderType = errors.New("the link type must be of folder type") + ErrLinkTypeMustToBeFileType = errors.New("the link type must be of file type") + ErrFolderIsNotEmpty = errors.New("folder can't be deleted becuase it is not empty") + ErrInternalErrorOnFileUpload = errors.New("either link or createFileResp must be not nil") + ErrMissingInputUploadAndCollectBlockData = errors.New("missing either session key or key ring") + ErrLinkMustNotBeNil = errors.New("missing input proton link") + ErrLinkMustBeActive = errors.New("can not operate on link state other than active") + ErrDownloadedBlockHashVerificationFailed = errors.New("the hash of the downloaded block doesn't match the original hash") +) diff --git a/file.go b/file.go new file mode 100644 index 0000000..68c16a6 --- /dev/null +++ b/file.go @@ -0,0 +1,457 @@ +package proton_api_bridge + +import ( + "bufio" + "bytes" + "context" + "crypto/sha256" + "encoding/base64" + "io" + "os" + "strings" + "time" + + "github.com/ProtonMail/gopenpgp/v2/crypto" + "github.com/gabriel-vasile/mimetype" + "github.com/henrybear327/go-proton-api" + "github.com/relvacode/iso8601" +) + +type FileSystemAttrs struct { + ModificationTime time.Time + Size int64 +} + +func (protonDrive *ProtonDrive) DownloadFileByID(ctx context.Context, linkID string) ([]byte, *FileSystemAttrs, error) { + link, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, linkID) + if err != nil { + return nil, nil, err + } + + return protonDrive.DownloadFile(ctx, &link) +} + +func (protonDrive *ProtonDrive) GetActiveRevision(ctx context.Context, link *proton.Link) (*proton.Revision, error) { + revisions, err := protonDrive.c.ListRevisions(ctx, protonDrive.MainShare.ShareID, link.LinkID) + if err != nil { + return nil, err + } + // log.Printf("revisions %#v", revisions) + + // Revisions are only for files, they represent “versions” of files. + // Each file can have 1 active revision and n obsolete revisions. + activeRevision := -1 + for i := range revisions { + if revisions[i].State == proton.RevisionStateActive { + activeRevision = i + } + } + + revision, err := protonDrive.c.GetRevisionAllBlocks(ctx, protonDrive.MainShare.ShareID, link.LinkID, revisions[activeRevision].ID) + if err != nil { + return nil, err + } + // log.Println("Total blocks", len(revision.Blocks)) + + return &revision, nil +} + +func (protonDrive *ProtonDrive) GetActiveRevisionWithAttrs(ctx context.Context, link *proton.Link) (*proton.Revision, *FileSystemAttrs, error) { + if link == nil { + return nil, nil, ErrLinkMustNotBeNil + } + + revision, err := protonDrive.GetActiveRevision(ctx, link) + if err != nil { + return nil, nil, err + } + + nodeKR, err := protonDrive.getNodeKR(ctx, link) + if err != nil { + return nil, nil, err + } + + revisionXAttrCommon, err := revision.GetDecXAttrString(protonDrive.AddrKR, nodeKR) + if err != nil { + return nil, nil, err + } + + modificationTime, err := iso8601.ParseString(revisionXAttrCommon.ModificationTime) + if err != nil { + return nil, nil, err + } + + return revision, &FileSystemAttrs{ + ModificationTime: modificationTime, + Size: revisionXAttrCommon.Size, + }, nil +} + +func (protonDrive *ProtonDrive) DownloadFile(ctx context.Context, link *proton.Link) ([]byte, *FileSystemAttrs, error) { + if link.Type != proton.LinkTypeFile { + return nil, nil, ErrLinkTypeMustToBeFileType + } + + parentNodeKR, err := protonDrive.getNodeKRByID(ctx, link.ParentLinkID) + if err != nil { + return nil, nil, err + } + + nodeKR, err := link.GetKeyRing(parentNodeKR, protonDrive.AddrKR) + if err != nil { + return nil, nil, err + } + + sessionKey, err := link.GetSessionKey(protonDrive.AddrKR, nodeKR) + if err != nil { + return nil, nil, err + } + + revision, fileSystemAttrs, err := protonDrive.GetActiveRevisionWithAttrs(ctx, link) + if err != nil { + return nil, nil, err + } + + buffer := bytes.NewBuffer(nil) + for i := range revision.Blocks { + // TODO: parallel download + blockReader, err := protonDrive.c.GetBlock(ctx, revision.Blocks[i].BareURL, revision.Blocks[i].Token) + if err != nil { + return nil, nil, err + } + defer blockReader.Close() + + err = decryptBlockIntoBuffer(sessionKey, protonDrive.AddrKR, nodeKR, revision.Blocks[i].Hash, revision.Blocks[i].EncSignature, buffer, blockReader) + if err != nil { + return nil, nil, err + } + } + + if fileSystemAttrs != nil { + return buffer.Bytes(), fileSystemAttrs, nil + } + return buffer.Bytes(), nil, nil +} + +func (protonDrive *ProtonDrive) UploadFileByReader(ctx context.Context, parentLinkID string, filename string, modTime time.Time, file io.Reader) (*proton.Link, int64, error) { + parentLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, parentLinkID) + if err != nil { + return nil, 0, err + } + + return protonDrive.uploadFile(ctx, &parentLink, filename, modTime, file) +} + +func (protonDrive *ProtonDrive) UploadFileByPath(ctx context.Context, parentLink *proton.Link, filename string, filePath string) (*proton.Link, int64, error) { + f, err := os.Open(filePath) + if err != nil { + return nil, 0, err + } + defer f.Close() + + info, err := os.Stat(filePath) + if err != nil { + return nil, 0, err + } + + in := bufio.NewReader(f) + + return protonDrive.uploadFile(ctx, parentLink, filename, info.ModTime(), in) +} + +func (protonDrive *ProtonDrive) createFileUploadDraft(ctx context.Context, parentLink *proton.Link, filename string, modTime time.Time, mimeType string) (*proton.Link, *proton.CreateFileRes, *crypto.SessionKey, *crypto.KeyRing, error) { + parentNodeKR, err := protonDrive.getNodeKR(ctx, parentLink) + if err != nil { + return nil, nil, nil, nil, err + } + + newNodeKey, newNodePassphraseEnc, newNodePassphraseSignature, err := generateNodeKeys(parentNodeKR, protonDrive.AddrKR) + if err != nil { + return nil, nil, nil, nil, err + } + + createFileReq := proton.CreateFileReq{ + ParentLinkID: parentLink.LinkID, + + // Name string // Encrypted File Name + // Hash string // Encrypted File Name hash + MIMEType: mimeType, // MIME Type + + // ContentKeyPacket string // The block's key packet, encrypted with the node key. + // ContentKeyPacketSignature string // Unencrypted signature of the content session key, signed with the NodeKey + + NodeKey: newNodeKey, // The private NodeKey, used to decrypt any file/folder content. + NodePassphrase: newNodePassphraseEnc, // The passphrase used to unlock the NodeKey, encrypted by the owning Link/Share keyring. + NodePassphraseSignature: newNodePassphraseSignature, // The signature of the NodePassphrase + + SignatureAddress: protonDrive.signatureAddress, // Signature email address used to sign passphrase and name + } + + /* Name is encrypted using the parent's keyring, and signed with address key */ + err = createFileReq.SetName(filename, protonDrive.AddrKR, parentNodeKR) + if err != nil { + return nil, nil, nil, nil, err + } + + parentHashKey, err := parentLink.GetHashKey(parentNodeKR) + if err != nil { + return nil, nil, nil, nil, err + } + + newNodeKR, err := getKeyRing(parentNodeKR, protonDrive.AddrKR, newNodeKey, newNodePassphraseEnc, newNodePassphraseSignature) + if err != nil { + return nil, nil, nil, nil, err + } + + err = createFileReq.SetHash(filename, parentHashKey) + if err != nil { + return nil, nil, nil, nil, err + } + + newSessionKey, err := createFileReq.SetContentKeyPacketAndSignature(newNodeKR, protonDrive.AddrKR) + if err != nil { + return nil, nil, nil, nil, err + } + + createFileResp, err := protonDrive.c.CreateFile(ctx, protonDrive.MainShare.ShareID, createFileReq) + if err != nil { + // FIXME: check for duplicated filename by using checkAvailableHashes + // FIXME: better error handling + // 422: A file or folder with that name already exists (Code=2500, Status=422) + if strings.Contains(err.Error(), "(Code=2500, Status=422)") { + // file name conflict, file already exists + link, err := protonDrive.SearchByNameInFolder(ctx, parentLink, filename, true, false) + if err != nil { + return nil, nil, nil, nil, err + } + return link, nil, nil, nil, nil + } + // other real error caught + return nil, nil, nil, nil, err + } + + return nil, &createFileResp, newSessionKey, newNodeKR, nil +} + +func (protonDrive *ProtonDrive) uploadAndCollectBlockData(ctx context.Context, newSessionKey *crypto.SessionKey, newNodeKR *crypto.KeyRing, fileContent []byte, linkID, revisionID string) ([]byte, []proton.BlockToken, error) { + if newSessionKey == nil || newNodeKR == nil { + return nil, nil, ErrMissingInputUploadAndCollectBlockData + } + + // FIXME: handle partial upload (failed midway) + // FIXME: get block size from the server config instead of hardcoding it + blockSize := UPLOAD_BLOCK_SIZE + type PendingUploadBlocks struct { + blockUploadInfo proton.BlockUploadInfo + encData []byte + } + blocks := make([]PendingUploadBlocks, 0) + manifestSignatureData := make([]byte, 0) + + for i := 0; i*blockSize < len(fileContent); i++ { + // encrypt data + upperBound := (i + 1) * blockSize + if upperBound > len(fileContent) { + upperBound = len(fileContent) + } + data := fileContent[i*blockSize : upperBound] + + dataPlainMessage := crypto.NewPlainMessage(data) + encData, err := newSessionKey.Encrypt(dataPlainMessage) + if err != nil { + return nil, nil, err + } + + encSignature, err := protonDrive.AddrKR.SignDetachedEncrypted(dataPlainMessage, newNodeKR) + if err != nil { + return nil, nil, err + } + encSignatureStr, err := encSignature.GetArmored() + if err != nil { + return nil, nil, err + } + + h := sha256.New() + h.Write(encData) + hash := h.Sum(nil) + base64Hash := base64.StdEncoding.EncodeToString(hash) + if err != nil { + return nil, nil, err + } + manifestSignatureData = append(manifestSignatureData, hash...) + + blocks = append(blocks, PendingUploadBlocks{ + blockUploadInfo: proton.BlockUploadInfo{ + Index: i + 1, // iOS drive: BE starts with 1 + Size: int64(len(encData)), + EncSignature: encSignatureStr, + Hash: base64Hash, + }, + encData: encData, + }) + } + + blockList := make([]proton.BlockUploadInfo, 0) + for i := 0; i < len(blocks); i++ { + blockList = append(blockList, blocks[i].blockUploadInfo) + } + blockTokens := make([]proton.BlockToken, 0) + blockUploadReq := proton.BlockUploadReq{ + AddressID: protonDrive.MainShare.AddressID, + ShareID: protonDrive.MainShare.ShareID, + LinkID: linkID, + RevisionID: revisionID, + + BlockList: blockList, + } + blockUploadResp, err := protonDrive.c.RequestBlockUpload(ctx, blockUploadReq) + if err != nil { + return nil, nil, err + } + + for i := range blockUploadResp { + err := protonDrive.c.UploadBlock(ctx, blockUploadResp[i].BareURL, blockUploadResp[i].Token, bytes.NewReader(blocks[i].encData)) + if err != nil { + return nil, nil, err + } + + blockTokens = append(blockTokens, proton.BlockToken{ + Index: i + 1, + Token: blockUploadResp[i].Token, + }) + } + + return manifestSignatureData, blockTokens, nil +} + +func (protonDrive *ProtonDrive) commitNewRevision(ctx context.Context, nodeKR *crypto.KeyRing, modificationTime time.Time, size int64, manifestSignatureData []byte, blockTokens []proton.BlockToken, linkID, revisionID string) error { + // TODO: check iOS Drive CommitableRevision + manifestSignature, err := protonDrive.AddrKR.SignDetached(crypto.NewPlainMessage(manifestSignatureData)) + if err != nil { + return err + } + manifestSignatureString, err := manifestSignature.GetArmored() + if err != nil { + return err + } + + updateRevisionReq := proton.UpdateRevisionReq{ + BlockList: blockTokens, + State: proton.RevisionStateActive, + ManifestSignature: manifestSignatureString, + SignatureAddress: protonDrive.signatureAddress, + } + err = updateRevisionReq.SetEncXAttrString(protonDrive.AddrKR, nodeKR, modificationTime, size) + if err != nil { + return err + } + + err = protonDrive.c.UpdateRevision(ctx, protonDrive.MainShare.ShareID, linkID, revisionID, updateRevisionReq) + if err != nil { + return err + } + + return nil +} + +func (protonDrive *ProtonDrive) uploadFile(ctx context.Context, parentLink *proton.Link, filename string, modTime time.Time, file io.Reader) (*proton.Link, int64, error) { + // FIXME: check iOS: optimize for large files -> enc blocks on the fly + // main issue lies in the mimetype detection, since a full readout is used + + // detect MIME type + fileContent, err := io.ReadAll(file) + if err != nil { + return nil, 0, err + } + fileSize := int64(len(fileContent)) + + mimetype.SetLimit(0) + mType := mimetype.Detect(fileContent) + mimeType := mType.String() + + /* step 1: create a draft */ + link, createFileResp, newSessionKey, newNodeKR, err := protonDrive.createFileUploadDraft(ctx, parentLink, filename, modTime, mimeType) + if err != nil { + return nil, 0, err + } + + linkID := "" + revisionID := "" + + if link != nil { + linkID = link.LinkID + + // get a new revision + newRevision, err := protonDrive.c.CreateRevision(ctx, protonDrive.MainShare.ShareID, linkID) + if err != nil { + return nil, 0, err + } + + revisionID = newRevision.ID + + // get newSessionKey and newNodeKR + parentNodeKR, err := protonDrive.getNodeKRByID(ctx, link.ParentLinkID) + if err != nil { + return nil, 0, err + } + newNodeKR, err = link.GetKeyRing(parentNodeKR, protonDrive.AddrKR) + if err != nil { + return nil, 0, err + } + newSessionKey, err = link.GetSessionKey(protonDrive.AddrKR, newNodeKR) + if err != nil { + return nil, 0, err + } + } else if createFileResp != nil { + linkID = createFileResp.ID + revisionID = createFileResp.RevisionID + } else { + // might be the case where the upload failed, since file search will not include file with type draft + return nil, 0, ErrInternalErrorOnFileUpload + } + + if fileSize == 0 { + /* step 2: upload blocks and collect block data */ + // skipped: no block to upload + + /* step 3: mark the file as active by updating the revision */ + manifestSignature := make([]byte, 0) + blockTokens := make([]proton.BlockToken, 0) + err = protonDrive.commitNewRevision(ctx, newNodeKR, modTime, fileSize, manifestSignature, blockTokens, linkID, revisionID) + if err != nil { + return nil, 0, err + } + } else { + /* step 2: upload blocks and collect block data */ + manifestSignatureData, blockTokens, err := protonDrive.uploadAndCollectBlockData(ctx, newSessionKey, newNodeKR, fileContent, linkID, revisionID) + if err != nil { + return nil, 0, err + } + + /* step 3: mark the file as active by updating the revision */ + err = protonDrive.commitNewRevision(ctx, newNodeKR, modTime, fileSize, manifestSignatureData, blockTokens, linkID, revisionID) + if err != nil { + return nil, 0, err + } + } + + finalLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, linkID) + if err != nil { + return nil, 0, err + } + return &finalLink, fileSize, nil +} + +/* +There is a route that proton-go-api doesn't have - checkAvailableHashes. +This is used to quickly find the next available filename when the originally supplied filename is taken in the current folder. + +Based on the code below, which is taken from the Proton iOS Drive app, we can infer that: +- when a file is to be uploaded && there is filename conflict after the first upload: + - on web, user will be prompted with a) overwrite b) keep both by appending filename with iteration number c) do nothing +- on the iOS client logic, we can see that when the filename conflict happens (after the upload attampt failed) + - the filename will be hashed by using filename + iteration + - 10 iterations will be done per batch, each iteration's hash will be sent to the server + - the server will return available hashes, and the client will take the lowest iteration as the filename to be used + - will be used to search for the next available filename (using hashes avoids the filename being known to the server) +*/ diff --git a/folder.go b/folder.go new file mode 100644 index 0000000..34e5388 --- /dev/null +++ b/folder.go @@ -0,0 +1,318 @@ +package proton_api_bridge + +import ( + "context" + "log" + "os" + + "github.com/ProtonMail/gopenpgp/v2/crypto" + "github.com/henrybear327/go-proton-api" +) + +type ProtonDirectoryData struct { + Link *proton.Link + Name string + IsFolder bool +} + +func (protonDrive *ProtonDrive) ListDirectory( + ctx context.Context, + folderLinkID string) ([]*ProtonDirectoryData, error) { + ret := make([]*ProtonDirectoryData, 0) + + folderLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, folderLinkID) + if err != nil { + return nil, err + } + + if folderLink.State == proton.LinkStateActive { + childrenLinks, err := protonDrive.c.ListChildren(ctx, protonDrive.MainShare.ShareID, folderLink.LinkID, true) + if err != nil { + return nil, err + } + + if childrenLinks != nil { + folderParentKR, err := protonDrive.getNodeKRByID(ctx, folderLink.ParentLinkID) + if err != nil { + return nil, err + } + defer folderParentKR.ClearPrivateParams() + folderLinkKR, err := folderLink.GetKeyRing(folderParentKR, protonDrive.AddrKR) + if err != nil { + return nil, err + } + defer folderLinkKR.ClearPrivateParams() + + for i := range childrenLinks { + if childrenLinks[i].State != proton.LinkStateActive { + continue + } + + name, err := childrenLinks[i].GetName(folderLinkKR, protonDrive.AddrKR) + if err != nil { + return nil, err + } + ret = append(ret, &ProtonDirectoryData{ + Link: &childrenLinks[i], + Name: name, + IsFolder: childrenLinks[i].Type == proton.LinkTypeFolder, + }) + } + } + } + + return ret, nil +} + +func (protonDrive *ProtonDrive) ListDirectoriesRecursively( + ctx context.Context, + parentNodeKR *crypto.KeyRing, + link *proton.Link, + download bool, + maxDepth, curDepth /* 0-based */ int, + excludeRoot bool, + pathSoFar string, + paths *[]string) error { + /* + Assumptions: + - we only care about the active ones + */ + if link.State != proton.LinkStateActive { + return nil + } + // log.Println("curDepth", curDepth, "pathSoFar", pathSoFar) + + var currentPath = "" + + if !(excludeRoot && curDepth == 0) { + name, err := link.GetName(parentNodeKR, protonDrive.AddrKR) + if err != nil { + return err + } + + currentPath = pathSoFar + "/" + name + // log.Println("currentPath", currentPath) + if paths != nil { + *paths = append(*paths, currentPath) + } + } + + if download { + if protonDrive.Config.DataFolderName == "" { + return ErrDataFolderNameIsEmpty + } + + if link.Type == proton.LinkTypeFile { + log.Println("Downloading", currentPath) + defer log.Println("Completes downloading", currentPath) + + byteArray, _, err := protonDrive.DownloadFile(ctx, link) + if err != nil { + return err + } + + err = os.WriteFile("./"+protonDrive.Config.DataFolderName+"/"+currentPath, byteArray, 0777) + if err != nil { + return err + } + } else /* folder */ { + if !(excludeRoot && curDepth == 0) { + // log.Println("Creating folder", currentPath) + // defer log.Println("Completes creating folder", currentPath) + + err := os.Mkdir("./"+protonDrive.Config.DataFolderName+"/"+currentPath, 0777) + if err != nil { + return err + } + } + } + } + + if maxDepth == -1 || curDepth < maxDepth { + if link.Type == proton.LinkTypeFolder { + childrenLinks, err := protonDrive.c.ListChildren(ctx, protonDrive.MainShare.ShareID, link.LinkID, true) + if err != nil { + return err + } + // log.Printf("childrenLinks len = %v, %#v", len(childrenLinks), childrenLinks) + + if childrenLinks != nil { + // get current node's keyring + linkKR, err := link.GetKeyRing(parentNodeKR, protonDrive.AddrKR) + if err != nil { + return err + } + defer linkKR.ClearPrivateParams() + + for _, childLink := range childrenLinks { + err = protonDrive.ListDirectoriesRecursively(ctx, linkKR, &childLink, download, maxDepth, curDepth+1, excludeRoot, currentPath, paths) + if err != nil { + return err + } + } + } + } + } + + return nil +} + +func (protonDrive *ProtonDrive) CreateNewFolderByID(ctx context.Context, parentLinkID string, folderName string) (string, error) { + parentLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, parentLinkID) + if err != nil { + return "", err + } + + return protonDrive.CreateNewFolder(ctx, &parentLink, folderName) +} + +func (protonDrive *ProtonDrive) CreateNewFolder(ctx context.Context, parentLink *proton.Link, folderName string) (string, error) { + // TODO: check for duplicated folder name + + parentNodeKR, err := protonDrive.getNodeKR(ctx, parentLink) + if err != nil { + return "", err + } + + newNodeKey, newNodePassphraseEnc, newNodePassphraseSignature, err := generateNodeKeys(parentNodeKR, protonDrive.AddrKR) + if err != nil { + return "", err + } + + createFolderReq := proton.CreateFolderReq{ + ParentLinkID: parentLink.LinkID, + + // Name string + // Hash string + + NodeKey: newNodeKey, + // NodeHashKey string + + NodePassphrase: newNodePassphraseEnc, + NodePassphraseSignature: newNodePassphraseSignature, + + SignatureAddress: protonDrive.signatureAddress, + } + + /* Name is encrypted using the parent's keyring, and signed with address key */ + err = createFolderReq.SetName(folderName, protonDrive.AddrKR, parentNodeKR) + if err != nil { + return "", err + } + + parentHashKey, err := parentLink.GetHashKey(parentNodeKR) + if err != nil { + return "", err + } + err = createFolderReq.SetHash(folderName, parentHashKey) + if err != nil { + return "", err + } + + newNodeKR, err := getKeyRing(parentNodeKR, protonDrive.AddrKR, newNodeKey, newNodePassphraseEnc, newNodePassphraseSignature) + if err != nil { + return "", err + } + err = createFolderReq.SetNodeHashKey(newNodeKR) + if err != nil { + return "", err + } + + createFolderResp, err := protonDrive.c.CreateFolder(ctx, protonDrive.MainShare.ShareID, createFolderReq) + if err != nil { + return "", err + } + + // log.Printf("createFolderResp %#v", createFolderResp) + + return createFolderResp.ID, nil +} + +func (protonDrive *ProtonDrive) MoveFileByID(ctx context.Context, srcLinkID, dstParentLinkID string, dstName string) error { + srcLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, srcLinkID) + if err != nil { + return err + } + if srcLink.State != proton.LinkStateActive { + return ErrLinkMustBeActive + } + + dstParentLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, dstParentLinkID) + if err != nil { + return err + } + if dstParentLink.State != proton.LinkStateActive { + return ErrLinkMustBeActive + } + + return protonDrive.MoveFile(ctx, &srcLink, &dstParentLink, dstName) +} + +func (protonDrive *ProtonDrive) MoveFile(ctx context.Context, srcLink *proton.Link, dstParentLink *proton.Link, dstName string) error { + return protonDrive.MoveFolder(ctx, srcLink, dstParentLink, dstName) +} + +func (protonDrive *ProtonDrive) MoveFolderByID(ctx context.Context, srcLinkID, dstParentLinkID, dstName string) error { + srcLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, srcLinkID) + if err != nil { + return err + } + if srcLink.State != proton.LinkStateActive { + return ErrLinkMustBeActive + } + + dstParentLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, dstParentLinkID) + if err != nil { + return err + } + if dstParentLink.State != proton.LinkStateActive { + return ErrLinkMustBeActive + } + + return protonDrive.MoveFolder(ctx, &srcLink, &dstParentLink, dstName) +} + +func (protonDrive *ProtonDrive) MoveFolder(ctx context.Context, srcLink *proton.Link, dstParentLink *proton.Link, dstName string) error { + return protonDrive.moveLink(ctx, srcLink, dstParentLink, dstName) +} + +func (protonDrive *ProtonDrive) moveLink(ctx context.Context, srcLink *proton.Link, dstParentLink *proton.Link, dstName string) error { + // we are moving the srcLink to under dstParentLink, with name dstName + req := proton.MoveLinkReq{ + ParentLinkID: dstParentLink.LinkID, + OriginalHash: srcLink.Hash, + SignatureAddress: protonDrive.signatureAddress, + } + + dstParentKR, err := protonDrive.getNodeKR(ctx, dstParentLink) + if err != nil { + return err + } + + err = req.SetName(dstName, protonDrive.AddrKR, dstParentKR) + if err != nil { + return err + } + + dstParentHashKey, err := dstParentLink.GetHashKey(dstParentKR) + if err != nil { + return err + } + err = req.SetHash(dstName, dstParentHashKey) + if err != nil { + return err + } + + srcParentKR, err := protonDrive.getNodeKRByID(ctx, srcLink.ParentLinkID) + if err != nil { + return err + } + nodePassphrase, err := reencryptKeyPacket(srcParentKR, dstParentKR, protonDrive.AddrKR, srcLink.NodePassphrase) + if err != nil { + return err + } + req.NodePassphrase = nodePassphrase + req.NodePassphraseSignature = srcLink.NodePassphraseSignature + + return protonDrive.c.MoveLink(ctx, protonDrive.MainShare.ShareID, srcLink.LinkID, req) +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..d79bb0a --- /dev/null +++ b/go.mod @@ -0,0 +1,36 @@ +module github.com/henrybear327/Proton-API-Bridge + +go 1.18 + +require ( + github.com/ProtonMail/gopenpgp/v2 v2.7.1 + github.com/gabriel-vasile/mimetype v1.4.2 + github.com/henrybear327/go-proton-api v0.0.0-20230628220324-22ba21ecb67f + github.com/relvacode/iso8601 v1.3.0 +) + +require ( + github.com/ProtonMail/bcrypt v0.0.0-20211005172633-e235017c1baf // indirect + github.com/ProtonMail/gluon v0.16.1-0.20230526091020-fb7689b15ae3 // indirect + github.com/ProtonMail/go-crypto v0.0.0-20230626094100-7e9e0395ebec // indirect + github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f // indirect + github.com/ProtonMail/go-srp v0.0.7 // indirect + github.com/PuerkitoBio/goquery v1.8.1 // indirect + github.com/andybalholm/cascadia v1.3.2 // indirect + github.com/bradenaw/juniper v0.13.0 // indirect + github.com/cloudflare/circl v1.3.3 // indirect + github.com/cronokirby/saferith v0.33.0 // indirect + github.com/emersion/go-message v0.16.0 // indirect + github.com/emersion/go-textwrapper v0.0.0-20200911093747-65d896831594 // indirect + github.com/emersion/go-vcard v0.0.0-20230626131229-38c18b295bbd // indirect + github.com/go-resty/resty/v2 v2.7.0 // indirect + github.com/google/uuid v1.3.0 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/sirupsen/logrus v1.9.3 // indirect + golang.org/x/crypto v0.10.0 // indirect + golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df // indirect + golang.org/x/net v0.11.0 // indirect + golang.org/x/sync v0.3.0 // indirect + golang.org/x/sys v0.9.0 // indirect + golang.org/x/text v0.10.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..13cec81 --- /dev/null +++ b/go.sum @@ -0,0 +1,144 @@ +github.com/Masterminds/semver/v3 v3.2.0 h1:3MEsd0SM6jqZojhjLWWeBY+Kcjy9i6MQAeY7YgDP83g= +github.com/ProtonMail/bcrypt v0.0.0-20210511135022-227b4adcab57/go.mod h1:HecWFHognK8GfRDGnFQbW/LiV7A3MX3gZVs45vk5h8I= +github.com/ProtonMail/bcrypt v0.0.0-20211005172633-e235017c1baf h1:yc9daCCYUefEs69zUkSzubzjBbL+cmOXgnmt9Fyd9ug= +github.com/ProtonMail/bcrypt v0.0.0-20211005172633-e235017c1baf/go.mod h1:o0ESU9p83twszAU8LBeJKFAAMX14tISa0yk4Oo5TOqo= +github.com/ProtonMail/gluon v0.16.1-0.20230526091020-fb7689b15ae3 h1:HsRC3WKWY2xf3OGfXnVn1S/EhJx/8dKrWX4/JJQIBc8= +github.com/ProtonMail/gluon v0.16.1-0.20230526091020-fb7689b15ae3/go.mod h1:xYLE11dCH40RrNjkuncXZbYjGyuHKeFtdYKT2nkq6M8= +github.com/ProtonMail/go-crypto v0.0.0-20230321155629-9a39f2531310/go.mod h1:8TI4H3IbrackdNgv+92dI+rhpCaLqM0IfpgCgenFvRE= +github.com/ProtonMail/go-crypto v0.0.0-20230626094100-7e9e0395ebec h1:vV3RryLxt42+ZIVOFbYJCH1jsZNTNmj2NYru5zfx+4E= +github.com/ProtonMail/go-crypto v0.0.0-20230626094100-7e9e0395ebec/go.mod h1:EjAoLdwvbIOoOQr3ihjnSoLZRtE8azugULFRteWMNc0= +github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f h1:tCbYj7/299ekTTXpdwKYF8eBlsYsDVoggDAuAjoK66k= +github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f/go.mod h1:gcr0kNtGBqin9zDW9GOHcVntrwnjrK+qdJ06mWYBybw= +github.com/ProtonMail/go-srp v0.0.7 h1:Sos3Qk+th4tQR64vsxGIxYpN3rdnG9Wf9K4ZloC1JrI= +github.com/ProtonMail/go-srp v0.0.7/go.mod h1:giCp+7qRnMIcCvI6V6U3S1lDDXDQYx2ewJ6F/9wdlJk= +github.com/ProtonMail/gopenpgp/v2 v2.7.1 h1:Awsg7MPc2gD3I7IFac2qE3Gdls0lZW8SzrFZ3k1oz0s= +github.com/ProtonMail/gopenpgp/v2 v2.7.1/go.mod h1:/BU5gfAVwqyd8EfC3Eu7zmuhwYQpKs+cGD8M//iiaxs= +github.com/PuerkitoBio/goquery v1.8.1 h1:uQxhNlArOIdbrH1tr0UXwdVFgDcZDrZVdcpygAcwmWM= +github.com/PuerkitoBio/goquery v1.8.1/go.mod h1:Q8ICL1kNUJ2sXGoAhPGUdYDJvgQgHzJsnnd3H7Ho5jQ= +github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA= +github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss= +github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU= +github.com/bradenaw/juniper v0.13.0 h1:KKMAiWDkRt45YUNzzw00Jec4nOgWDLVtztjf39E0ppI= +github.com/bradenaw/juniper v0.13.0/go.mod h1:Z2B7aJlQ7xbfWsnMLROj5t/5FQ94/MkIdKC30J4WvzI= +github.com/bwesterb/go-ristretto v1.2.0/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= +github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= +github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s= +github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams= +github.com/cloudflare/circl v1.1.0/go.mod h1:prBCrKB9DV4poKZY1l9zBXg2QJY7mvgRvtMxxK7fi4I= +github.com/cloudflare/circl v1.3.3 h1:fE/Qz0QdIGqeWfnwq0RE0R7MI51s0M2E4Ga9kq5AEMs= +github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA= +github.com/cronokirby/saferith v0.33.0 h1:TgoQlfsD4LIwx71+ChfRcIpjkw+RPOapDEVxa+LhwLo= +github.com/cronokirby/saferith v0.33.0/go.mod h1:QKJhjoqUtBsXCAVEjw38mFqoi7DebT7kthcD7UzbnoA= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/emersion/go-message v0.16.0 h1:uZLz8ClLv3V5fSFF/fFdW9jXjrZkXIpE1Fn8fKx7pO4= +github.com/emersion/go-message v0.16.0/go.mod h1:pDJDgf/xeUIF+eicT6B/hPX/ZbEorKkUMPOxrPVG2eQ= +github.com/emersion/go-textwrapper v0.0.0-20200911093747-65d896831594 h1:IbFBtwoTQyw0fIM5xv1HF+Y+3ZijDR839WMulgxCcUY= +github.com/emersion/go-textwrapper v0.0.0-20200911093747-65d896831594/go.mod h1:aqO8z8wPrjkscevZJFVE1wXJrLpC5LtJG7fqLOsPb2U= +github.com/emersion/go-vcard v0.0.0-20230626131229-38c18b295bbd h1:n1kH4lDJLDgO8sqkt0QgeQXKims1L8khdgilk9G5lm8= +github.com/emersion/go-vcard v0.0.0-20230626131229-38c18b295bbd/go.mod h1:HMJKR5wlh/ziNp+sHEDV2ltblO4JD2+IdDOWtGcQBTM= +github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU= +github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA= +github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= +github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg= +github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= +github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= +github.com/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js= +github.com/go-resty/resty/v2 v2.7.0 h1:me+K9p3uhSmXtrBZ4k9jcEAfJmuC8IivWHwaLZwPrFY= +github.com/go-resty/resty/v2 v2.7.0/go.mod h1:9PWDzw47qPphMRFfhsyk0NnSgvluHcljSMVIq3w7q0I= +github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= +github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/henrybear327/go-proton-api v0.0.0-20230628220324-22ba21ecb67f h1:OzLwkcwQZLkFnA0KpPVltWmw59Vq1XeJ9IzDjFvLdi4= +github.com/henrybear327/go-proton-api v0.0.0-20230628220324-22ba21ecb67f/go.mod h1:l42xBSOrCmkAxzWUHcoUsG/cP8m1hMhV72GoChOX3bg= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk= +github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q= +github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/relvacode/iso8601 v1.3.0 h1:HguUjsGpIMh/zsTczGN3DVJFxTU/GX+MMmzcKoMO7ko= +github.com/relvacode/iso8601 v1.3.0/go.mod h1:FlNp+jz+TXpyRqgmM7tnzHHzBnz776kmAH2h3sZCn0I= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY= +github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= +github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A= +golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4= +golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU= +golang.org/x/crypto v0.10.0 h1:LKqV2xt9+kDzSTfOhx4FrkEBcMrAgHSYgzywV9zcGmM= +golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I= +golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df h1:UA2aFVmmsIlefxMk29Dp2juaUSth8Pyn3Tq5Y5mJGME= +golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210916014120-12bc252f5db8/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211029224645-99673261e6eb/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= +golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= +golang.org/x/net v0.11.0 h1:Gi2tvZIJyBtO9SDr1q9h5hEQCp/4L2RQ+ar0qjx2oNU= +golang.org/x/net v0.11.0/go.mod h1:2L/ixqYpgIVXmeoSA/4Lu7BzTG4KIyPIryS4IsOd1oQ= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E= +golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.9.0 h1:KS/R3tvhPqvJvwcKfnBHJwwthS11LRhmM5D59eEXa0s= +golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U= +golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.10.0 h1:UpjohKhiEgNc0CSauXmwYftY1+LlaC75SJwh0SgCX58= +golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/keyring.go b/keyring.go new file mode 100644 index 0000000..abc3a15 --- /dev/null +++ b/keyring.go @@ -0,0 +1,51 @@ +package proton_api_bridge + +import ( + "context" + + "github.com/ProtonMail/gopenpgp/v2/crypto" + "github.com/henrybear327/go-proton-api" +) + +func (protonDrive *ProtonDrive) getNodeKRByID(ctx context.Context, linkID string) (*crypto.KeyRing, error) { + if linkID == "" { + // most likely someone requested parent link, which happen to be "" + return protonDrive.MainShareKR, nil + } + + link, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, linkID) + if err != nil { + return nil, err + } + + return protonDrive.getNodeKR(ctx, &link) +} + +func (protonDrive *ProtonDrive) getNodeKR(ctx context.Context, link *proton.Link) (*crypto.KeyRing, error) { + if link.ParentLinkID == "" { + nodeKR, err := link.GetKeyRing(protonDrive.MainShareKR, protonDrive.AddrKR) + if err != nil { + return nil, err + } + + return nodeKR, nil + } + + parentLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, link.ParentLinkID) + if err != nil { + return nil, err + } + + // parentNodeKR is used to decrypt the current node's KR, as each node has its keyring, which can be decrypted by its parent + parentNodeKR, err := protonDrive.getNodeKR(ctx, &parentLink) + if err != nil { + return nil, err + } + + nodeKR, err := link.GetKeyRing(parentNodeKR, protonDrive.AddrKR) + if err != nil { + return nil, err + } + + return nodeKR, nil +} diff --git a/search.go b/search.go new file mode 100644 index 0000000..3597b8d --- /dev/null +++ b/search.go @@ -0,0 +1,180 @@ +package proton_api_bridge + +import ( + "context" + + "github.com/ProtonMail/gopenpgp/v2/crypto" + "github.com/henrybear327/go-proton-api" +) + +/* +Observation: file name is unique, since it's checked (by hash) on the server +*/ + +func (protonDrive *ProtonDrive) SearchByNameRecursivelyFromRoot(ctx context.Context, targetName string, isFolder bool) (*proton.Link, error) { + var linkType proton.LinkType + if isFolder { + linkType = proton.LinkTypeFolder + } else { + linkType = proton.LinkTypeFile + } + return protonDrive.searchByNameRecursively(ctx, protonDrive.MainShareKR, protonDrive.RootLink, targetName, linkType) +} + +func (protonDrive *ProtonDrive) SearchByNameRecursivelyByID(ctx context.Context, folderLinkID string, targetName string, isFolder bool) (*proton.Link, error) { + folderLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, folderLinkID) + if err != nil { + return nil, err + } + + var linkType proton.LinkType + if isFolder { + linkType = proton.LinkTypeFolder + } else { + linkType = proton.LinkTypeFile + } + + if folderLink.Type != proton.LinkTypeFolder { + return nil, ErrLinkTypeMustToBeFolderType + } + folderKeyRing, err := protonDrive.getNodeKRByID(ctx, folderLink.ParentLinkID) + if err != nil { + return nil, err + } + return protonDrive.searchByNameRecursively(ctx, folderKeyRing, &folderLink, targetName, linkType) +} + +func (protonDrive *ProtonDrive) SearchByNameRecursively(ctx context.Context, folderLink *proton.Link, targetName string, isFolder bool) (*proton.Link, error) { + var linkType proton.LinkType + if isFolder { + linkType = proton.LinkTypeFolder + } else { + linkType = proton.LinkTypeFile + } + + if folderLink.Type != proton.LinkTypeFolder { + return nil, ErrLinkTypeMustToBeFolderType + } + folderKeyRing, err := protonDrive.getNodeKRByID(ctx, folderLink.ParentLinkID) + if err != nil { + return nil, err + } + return protonDrive.searchByNameRecursively(ctx, folderKeyRing, folderLink, targetName, linkType) +} + +func (protonDrive *ProtonDrive) searchByNameRecursively( + ctx context.Context, + parentNodeKR *crypto.KeyRing, + link *proton.Link, + targetName string, + linkType proton.LinkType) (*proton.Link, error) { + /* + Assumptions: + - we only care about the active ones + */ + if link.State != proton.LinkStateActive { + return nil, nil + } + + name, err := link.GetName(parentNodeKR, protonDrive.AddrKR) + if err != nil { + return nil, err + } + + if link.Type == linkType && name == targetName { + return link, nil + } + + if link.Type == proton.LinkTypeFolder { + childrenLinks, err := protonDrive.c.ListChildren(ctx, protonDrive.MainShare.ShareID, link.LinkID, true) + if err != nil { + return nil, err + } + // log.Printf("childrenLinks len = %v, %#v", len(childrenLinks), childrenLinks) + + // get current node's keyring + linkKR, err := link.GetKeyRing(parentNodeKR, protonDrive.AddrKR) + if err != nil { + return nil, err + } + defer linkKR.ClearPrivateParams() + + for _, childLink := range childrenLinks { + ret, err := protonDrive.searchByNameRecursively(ctx, linkKR, &childLink, targetName, linkType) + if err != nil { + return nil, err + } + + if ret != nil { + return ret, nil + } + } + } + + return nil, nil +} + +// if the target isn't found, nil will be returned for both return values +func (protonDrive *ProtonDrive) SearchByNameInFolderByID(ctx context.Context, + folderLinkID string, + targetName string, + searchForFile, searchForFolder bool) (*proton.Link, error) { + folderLink, err := protonDrive.c.GetLink(ctx, protonDrive.MainShare.ShareID, folderLinkID) + if err != nil { + return nil, err + } + + return protonDrive.SearchByNameInFolder(ctx, &folderLink, targetName, searchForFile, searchForFolder) +} + +func (protonDrive *ProtonDrive) SearchByNameInFolder( + ctx context.Context, + folderLink *proton.Link, + targetName string, + searchForFile, searchForFolder bool) (*proton.Link, error) { + if !searchForFile && !searchForFolder { + // nothing to search + return nil, nil + } + + // we search all folders and files within this designated folder only + if folderLink.Type != proton.LinkTypeFolder { + return nil, ErrLinkTypeMustToBeFolderType + } + + parentNodeKR, err := protonDrive.getNodeKRByID(ctx, folderLink.ParentLinkID) + if err != nil { + return nil, err + } + + // get current node's keyring + folderLinkKR, err := folderLink.GetKeyRing(parentNodeKR, protonDrive.AddrKR) + if err != nil { + return nil, err + } + defer folderLinkKR.ClearPrivateParams() + + childrenLinks, err := protonDrive.c.ListChildren(ctx, protonDrive.MainShare.ShareID, folderLink.LinkID, true) + if err != nil { + return nil, err + } + for _, childLink := range childrenLinks { + if childLink.State != proton.LinkStateActive { + // we only search in the active folders + continue + } + + name, err := childLink.GetName(folderLinkKR, protonDrive.AddrKR) + if err != nil { + return nil, err + } + + if searchForFile && childLink.Type == proton.LinkTypeFile && name == targetName { + return &childLink, nil + } else if searchForFolder && childLink.Type == proton.LinkTypeFolder && name == targetName { + return &childLink, nil + } + } + + return nil, nil +} diff --git a/shares.go b/shares.go new file mode 100644 index 0000000..053ef34 --- /dev/null +++ b/shares.go @@ -0,0 +1,25 @@ +package proton_api_bridge + +import ( + "context" + + "github.com/henrybear327/go-proton-api" +) + +func getAllShares(ctx context.Context, c *proton.Client) ([]proton.ShareMetadata, error) { + shares, err := c.ListShares(ctx, true) + if err != nil { + return nil, err + } + + return shares, nil +} + +func getShareByID(ctx context.Context, c *proton.Client, shareID string) (*proton.Share, error) { + share, err := c.GetShare(ctx, shareID) + if err != nil { + return nil, err + } + + return &share, nil +} diff --git a/testcase/empty.txt b/testcase/empty.txt new file mode 100644 index 0000000..e69de29 diff --git a/testcase/integrationTestImage.png b/testcase/integrationTestImage.png new file mode 100644 index 0000000000000000000000000000000000000000..87032789adc7c8a3f8a2f945297ff195c1ad22e9 GIT binary patch literal 49613 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 literal 0 HcmV?d00001 diff --git a/testcase/integrationTestImage2.png b/testcase/integrationTestImage2.png new file mode 100644 index 0000000000000000000000000000000000000000..fd51a7ea730323e01d0fb1c8085f3c086b7639d6 GIT binary patch literal 328557 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 z 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%0AECcU^eF~_t-rk? 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

Scf~7K0ULUFraPZ| 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 literal 0 HcmV?d00001 diff --git a/utility/init.go b/utility/init.go new file mode 100644 index 0000000..ffd655d --- /dev/null +++ b/utility/init.go @@ -0,0 +1,9 @@ +package utility + +import ( + "log" +) + +func SetupLog() { + log.SetFlags(log.LstdFlags | log.Lshortfile) +} diff --git a/volumes.go b/volumes.go new file mode 100644 index 0000000..d4e4e30 --- /dev/null +++ b/volumes.go @@ -0,0 +1,16 @@ +package proton_api_bridge + +import ( + "context" + + "github.com/henrybear327/go-proton-api" +) + +func listAllVolumes(ctx context.Context, c *proton.Client) ([]proton.Volume, error) { + volumes, err := c.ListVolumes(ctx) + if err != nil { + return nil, err + } + + return volumes, nil +}