imap-backup 2.1.1 → 3.0.0

data/lib/email/provider.rb

@@ -1,6 +1,8 @@
 module Email; end
 
 class Email::Provider
+  GMAIL_IMAP_SERVER = "imap.gmail.com".freeze
+
   def self.for_address(address)
     case
     when address.end_with?("@fastmail.com")
@@ -27,7 +29,7 @@ class Email::Provider
   def host
     case provider
     when :gmail
-      "imap.gmail.com"
+      GMAIL_IMAP_SERVER
     when :fastmail
       "imap.fastmail.com"
     end

data/lib/gmail/authenticator.rb

@@ -0,0 +1,160 @@
+require "googleauth"
+require "google/auth/stores/in_memory_token_store"
+
+module Gmail; end
+
+class Gmail::Authenticator
+  class MalformedImapBackupToken < StandardError; end
+
+  class ImapBackupToken
+    attr_reader :token
+
+    def self.from(
+      access_token:,
+      client_id:,
+      client_secret:,
+      expiration_time_millis:,
+      refresh_token:
+    )
+      {
+        access_token: access_token,
+        client_id: client_id,
+        client_secret: client_secret,
+        expiration_time_millis: expiration_time_millis,
+        refresh_token: refresh_token
+      }.to_json
+    end
+
+    def initialize(token)
+      @token = token
+    end
+
+    def valid?
+      return false if !body
+      return false if !access_token
+      return false if !client_id
+      return false if !client_secret
+      return false if !expiration_time_millis
+      return false if !refresh_token
+
+      true
+    end
+
+    def access_token
+      body["access_token"]
+    end
+
+    def client_id
+      body["client_id"]
+    end
+
+    def client_secret
+      body["client_secret"]
+    end
+
+    def expiration_time_millis
+      body["expiration_time_millis"]
+    end
+
+    def refresh_token
+      body["refresh_token"]
+    end
+
+    private
+
+    def body
+      @body ||= JSON.parse(token)
+    rescue JSON::ParserError
+      nil
+    end
+  end
+
+  GMAIL_READ_SCOPE = "https://mail.google.com/".freeze
+  OOB_URI = "urn:ietf:wg:oauth:2.0:oob".freeze
+
+  attr_reader :email
+  attr_reader :token
+
+  def self.refresh_token?(text)
+    ImapBackupToken.new(text).valid?
+  end
+
+  def initialize(email:, token:)
+    @email = email
+    @token = token
+  end
+
+  def authorization_url
+    authorizer.get_authorization_url(base_url: OOB_URI)
+  end
+
+  def credentials
+    authorizer.get_credentials(email).tap do |c|
+      c.refresh! if c.expired?
+    end
+  end
+
+  def credentials_from_code(code)
+    authorizer.get_credentials_from_code(
+      user_id: email,
+      code: code,
+      base_url: OOB_URI
+    )
+  end
+
+  private
+
+  def auth_client_id
+    @auth_client_id = Google::Auth::ClientId.new(client_id, client_secret)
+  end
+
+  def authorizer
+    @authorizer ||= Google::Auth::UserAuthorizer.new(
+      auth_client_id, GMAIL_READ_SCOPE, token_store
+    )
+  end
+
+  def access_token
+    imap_backup_token.access_token
+  end
+
+  def client_id
+    imap_backup_token.client_id
+  end
+
+  def client_secret
+    imap_backup_token.client_secret
+  end
+
+  def expiration_time_millis
+    imap_backup_token.expiration_time_millis
+  end
+
+  def refresh_token
+    imap_backup_token.refresh_token
+  end
+
+  def imap_backup_token
+    @imap_backup_token ||=
+      ImapBackupToken.new(token).tap do |t|
+        raise MalformedImapBackupToken if !t.valid?
+      end
+  end
+
+  def store_token
+    {
+      "client_id" => client_id,
+      "access_token" => access_token,
+      "refresh_token" => refresh_token,
+      "scope": [GMAIL_READ_SCOPE],
+      "expiration_time_millis": expiration_time_millis
+    }.to_json
+  end
+
+  def token_store
+    @token_store ||=
+      Google::Auth::Stores::InMemoryTokenStore.new.tap do |t|
+        t.store(email, store_token)
+      end
+  end
+end

data/lib/google/auth/stores/in_memory_token_store.rb

@@ -0,0 +1,9 @@
+module Google; end
+module Google::Auth; end
+module Google::Auth::Stores; end
+
+class Google::Auth::Stores::InMemoryTokenStore < Hash
+  def load(id)
+    self[id]
+  end
+end

data/lib/imap/backup.rb

@@ -7,6 +7,7 @@ require "imap/backup/configuration/account"
 require "imap/backup/configuration/asker"
 require "imap/backup/configuration/connection_tester"
 require "imap/backup/configuration/folder_chooser"
+require "imap/backup/configuration/gmail_oauth2"
 require "imap/backup/configuration/list"
 require "imap/backup/configuration/setup"
 require "imap/backup/configuration/store"
@@ -28,7 +29,7 @@ module Imap::Backup
     attr_reader :logger
 
     def initialize
-      @logger = ::Logger.new(STDOUT)
+      @logger = ::Logger.new($stdout)
     end
   end
 

data/lib/imap/backup/account/connection.rb

@@ -1,9 +1,14 @@
 require "net/imap"
+require "gmail_xoauth"
+
+require "gmail/authenticator"
 
 module Imap::Backup
   module Account; end
 
   class Account::Connection
+    class InvalidGmailOauth2RefreshToken < StandardError; end
+
     attr_reader :connection_options
     attr_reader :local_path
     attr_reader :password
@@ -57,27 +62,7 @@ module Imap::Backup
 
     def restore
       local_folders do |serializer, folder|
-        exists = folder.exist?
-        if exists
-          new_name = serializer.apply_uid_validity(folder.uid_validity)
-          old_name = serializer.folder
-          if new_name
-            Imap::Backup.logger.debug(
-              "Backup '#{old_name}' renamed and restored to '#{new_name}'"
-            )
-            new_serializer = Serializer::Mbox.new(local_path, new_name)
-            new_folder = Account::Folder.new(self, new_name)
-            new_folder.create
-            new_serializer.force_uid_validity(new_folder.uid_validity)
-            Uploader.new(new_folder, new_serializer).run
-          else
-            Uploader.new(folder, serializer).run
-          end
-        else
-          folder.create
-          serializer.force_uid_validity(folder.uid_validity)
-          Uploader.new(folder, serializer).run
-        end
+        restore_folder serializer, folder
       end
     end
 
@@ -98,12 +83,34 @@ module Imap::Backup
         "Creating IMAP instance: #{server}, options: #{options.inspect}"
       )
       @imap = Net::IMAP.new(server, options)
-      Imap::Backup.logger.debug "Logging in: #{username}/#{masked_password}"
-      @imap.login(username, password)
+      if gmail? && Gmail::Authenticator.refresh_token?(password)
+        authenticator = Gmail::Authenticator.new(email: username, token: password)
+        credentials = authenticator.credentials
+        raise InvalidGmailOauth2RefreshToken if !credentials
+
+        Imap::Backup.logger.debug "Logging in with OAuth2 token: #{username}"
+        @imap.authenticate("XOAUTH2", username, credentials.access_token)
+      else
+        Imap::Backup.logger.debug "Logging in: #{username}/#{masked_password}"
+        @imap.login(username, password)
+      end
       Imap::Backup.logger.debug "Login complete"
       @imap
     end
 
+    def server
+      return @server if @server
+      return nil if provider.nil?
+
+      @server = provider.host
+    end
+
+    def backup_folders
+      return @backup_folders if @backup_folders && !@backup_folders.empty?
+
+      (folders || []).map { |f| {name: f.name} }
+    end
+
     private
 
     def each_folder
@@ -114,6 +121,33 @@ module Imap::Backup
       end
     end
 
+    def restore_folder(serializer, folder)
+      existing_uids = folder.uids
+      if existing_uids.any?
+        Imap::Backup.logger.debug(
+          "There's already a '#{folder.name}' folder with emails"
+        )
+        new_name = serializer.apply_uid_validity(folder.uid_validity)
+        old_name = serializer.folder
+        if new_name
+          Imap::Backup.logger.debug(
+            "Backup '#{old_name}' renamed and restored to '#{new_name}'"
+          )
+          new_serializer = Serializer::Mbox.new(local_path, new_name)
+          new_folder = Account::Folder.new(self, new_name)
+          new_folder.create
+          new_serializer.force_uid_validity(new_folder.uid_validity)
+          Uploader.new(new_folder, new_serializer).run
+        else
+          Uploader.new(folder, serializer).run
+        end
+      else
+        folder.create
+        serializer.force_uid_validity(folder.uid_validity)
+        Uploader.new(folder, serializer).run
+      end
+    end
+
     def create_account_folder
       Utils.make_folder(
         File.dirname(local_path),
@@ -126,10 +160,8 @@ module Imap::Backup
       password.gsub(/./, "x")
     end
 
-    def backup_folders
-      return @backup_folders if @backup_folders && !@backup_folders.empty?
-
-      (folders || []).map { |f| {name: f.name} }
+    def gmail?
+      server == Email::Provider::GMAIL_IMAP_SERVER
     end
 
     def local_folders
@@ -147,13 +179,6 @@ module Imap::Backup
       @provider ||= Email::Provider.for_address(username)
     end
 
-    def server
-      return @server if @server
-      return nil if provider.nil?
-
-      @server = provider.host
-    end
-
     def provider_options
       provider.options.merge(connection_options)
     end

data/lib/imap/backup/account/folder.rb

@@ -52,6 +52,16 @@ module Imap::Backup
       imap.uid_search(["ALL"]).sort
     rescue FolderNotFound
       []
+    rescue NoMethodError
+      message = <<~MESSAGE
+        Folder '#{name}' caused NoMethodError
+        probably
+        `undefined method `[]' for nil:NilClass (NoMethodError)`
+        in `search_internal` in stdlib net/imap.rb.
+        This is caused by `@responses["SEARCH"] being unset/undefined
+      MESSAGE
+      Imap::Backup.logger.warn message
+      []
     end
 
     def fetch(uid)
@@ -63,7 +73,6 @@ module Imap::Backup
       attributes = fetch_data_item.attr
       return nil if !attributes.key?("RFC822")
 
-      attributes["RFC822"].force_encoding("utf-8")
       attributes
     rescue FolderNotFound
       nil

data/lib/imap/backup/configuration/account.rb

@@ -56,9 +56,11 @@ module Imap::Backup
           )
         else
           account[:username] = username
+          # rubocop:disable Style/IfUnlessModifier
           if account[:server].nil? || (account[:server] == "")
             account[:server] = default_server(username)
           end
+          # rubocop:enable Style/IfUnlessModifier
           account[:modified] = true
         end
       end
@@ -66,7 +68,13 @@ module Imap::Backup
 
     def modify_password(menu)
       menu.choice("modify password") do
-        password = Configuration::Asker.password
+        password =
+          if account[:server] == Email::Provider::GMAIL_IMAP_SERVER
+            Configuration::GmailOauth2.new(account).run
+          else
+            Configuration::Asker.password
+          end
+
         if !password.nil?
           account[:password] = password
           account[:modified] = true

data/lib/imap/backup/configuration/gmail_oauth2.rb

@@ -0,0 +1,82 @@
+module Imap::Backup
+  module Configuration; end
+
+  class Configuration::GmailOauth2
+    BANNER = <<~BANNER.freeze
+      GMail OAuth2 Setup
+
+      You need to authorize imap_backup to get access to your email.
+      To do so, please follow the instructions here:
+
+      https://github.com/joeyates/imap-backup/docs/setting-up-gmail.md
+
+    BANNER
+
+    GMAIL_READ_SCOPE = "https://mail.google.com/".freeze
+    OOB_URI = "urn:ietf:wg:oauth:2.0:oob".freeze
+
+    attr_reader :account
+    attr_reader :client_id
+    attr_reader :client_secret
+
+    def initialize(account)
+      @account = account
+    end
+
+    def run
+      Kernel.system("clear")
+      Kernel.puts BANNER
+      @client_id = highline.ask("client_id: ")
+      @client_secret = highline.ask("client_secret: ")
+
+      Kernel.puts <<~MESSAGE
+
+        Open the following URL in your browser
+
+        #{authorization_url}
+
+        Then copy the success code
+
+      MESSAGE
+
+      @code = highline.ask("success code: ")
+      @credentials = authorizer.get_and_store_credentials_from_code(
+        user_id: email, code: @code, base_url: OOB_URI
+      )
+
+      raise "Failed" if !@credentials
+
+      token = JSON.parse(token_store.load(email))
+      token["client_secret"] = client_secret
+      token.to_json
+    end
+
+    private
+
+    def email
+      account[:username]
+    end
+
+    def highline
+      Configuration::Setup.highline
+    end
+
+    def auth_client_id
+      @auth_client_id = Google::Auth::ClientId.new(client_id, client_secret)
+    end
+
+    def authorizer
+      @authorizer ||= Google::Auth::UserAuthorizer.new(
+        auth_client_id, GMAIL_READ_SCOPE, token_store
+      )
+    end
+
+    def token_store
+      @token_store ||= Google::Auth::Stores::InMemoryTokenStore.new
+    end
+
+    def authorization_url
+      authorizer.get_authorization_url(base_url: OOB_URI)
+    end
+  end
+end