fastlane 1.111.0 → 2.0.1

data/cert/lib/cert.rb

@@ -0,0 +1,18 @@
+require 'cert/runner'
+require 'cert/options'
+
+require 'fastlane_core'
+require 'spaceship'
+
+module Cert
+  # Use this to just setup the configuration attribute and set it later somewhere else
+  class << self
+    attr_accessor :config
+  end
+
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  ROOT = Pathname.new(File.expand_path('../..', __FILE__))
+
+  ENV['FASTLANE_TEAM_ID'] ||= ENV["CERT_TEAM_ID"]
+end

data/cert/lib/cert/commands_generator.rb

@@ -0,0 +1,51 @@
+require 'commander'
+
+HighLine.track_eof = false
+
+module Cert
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      self.new.run
+    end
+
+    def run
+      program :name, 'cert'
+      program :version, Fastlane::VERSION
+      program :description, 'CLI for \'cert\' - Create new iOS code signing certificates'
+      program :help, 'Author', 'Felix Krause <cert@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'GitHub', 'https://github.com/fastlane/cert'
+      program :help_formatter, :compact
+
+      global_option('--verbose') { $verbose = true }
+
+      FastlaneCore::CommanderGenerator.new.generate(Cert::Options.available_options)
+
+      command :create do |c|
+        c.syntax = 'cert create'
+        c.description = 'Create new iOS code signing certificates'
+
+        c.action do |args, options|
+          Cert.config = FastlaneCore::Configuration.create(Cert::Options.available_options, options.__hash__)
+          Cert::Runner.new.launch
+        end
+      end
+
+      command :revoke_expired do |c|
+        c.syntax = 'cert revoke_expired'
+        c.description = 'Revoke expired iOS code signing certificates'
+
+        c.action do |args, options|
+          Cert.config = FastlaneCore::Configuration.create(Cert::Options.available_options, options.__hash__)
+          Cert::Runner.new.revoke_expired_certs!
+        end
+      end
+
+      default_command :create
+
+      run!
+    end
+  end
+end

data/cert/lib/cert/options.rb

@@ -0,0 +1,67 @@
+require 'fastlane_core'
+require 'credentials_manager'
+
+module Cert
+  class Options
+    def self.available_options
+      user = CredentialsManager::AppfileConfig.try_fetch_value(:apple_dev_portal_id)
+      user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+
+      [
+        FastlaneCore::ConfigItem.new(key: :development,
+                                     env_name: "CERT_DEVELOPMENT",
+                                     description: "Create a development certificate instead of a distribution one",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :force,
+                                     env_name: "CERT_FORCE",
+                                     description: "Create a certificate even if an existing certificate exists",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :username,
+                                     short_option: "-u",
+                                     env_name: "CERT_USERNAME",
+                                     description: "Your Apple ID Username",
+                                     default_value: user),
+        FastlaneCore::ConfigItem.new(key: :team_id,
+                                     short_option: "-b",
+                                     env_name: "CERT_TEAM_ID",
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_id),
+                                     description: "The ID of your Developer Portal team if you're in multiple teams",
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_TEAM_ID"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :team_name,
+                                     short_option: "-l",
+                                     env_name: "CERT_TEAM_NAME",
+                                     description: "The name of your Developer Portal team if you're in multiple teams",
+                                     optional: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_name),
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_TEAM_NAME"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :output_path,
+                                     short_option: "-o",
+                                     env_name: "CERT_OUTPUT_PATH",
+                                     description: "The path to a directory in which all certificates and private keys should be stored",
+                                     default_value: "."),
+        FastlaneCore::ConfigItem.new(key: :keychain_path,
+                                     short_option: "-k",
+                                     env_name: "CERT_KEYCHAIN_PATH",
+                                     description: "Path to a custom keychain",
+                                     default_value: Dir["#{Dir.home}/Library/Keychains/login.keychain", "#{Dir.home}/Library/Keychains/login.keychain-db"].last,
+                                     verify_block: proc do |value|
+                                       value = File.expand_path(value)
+                                       UI.user_error!("Keychain not found at path '#{value}'") unless File.exist?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :keychain_password,
+                                     short_option: "-p",
+                                     env_name: "CERT_KEYCHAIN_PASSWORD",
+                                     sensitive: true,
+                                     description: "This might be required the first time you access certificates on a new mac. For the login/default keychain this is your account password",
+                                     optional: true)
+      ]
+    end
+  end
+end

data/cert/lib/cert/runner.rb

@@ -0,0 +1,181 @@
+require 'fileutils'
+
+module Cert
+  class Runner
+    def launch
+      run
+
+      installed = FastlaneCore::CertChecker.installed?(ENV["CER_FILE_PATH"])
+      UI.message "Verifying the certificate is properly installed locally..."
+      UI.user_error!("Could not find the newly generated certificate installed", show_github_issues: true) unless installed
+      UI.success "Successfully installed certificate #{ENV['CER_CERTIFICATE_ID']}"
+      return ENV["CER_FILE_PATH"]
+    end
+
+    def login
+      UI.message "Starting login with user '#{Cert.config[:username]}'"
+      Spaceship.login(Cert.config[:username], nil)
+      Spaceship.select_team
+      UI.message "Successfully logged in"
+    end
+
+    def run
+      FileUtils.mkdir_p(Cert.config[:output_path])
+
+      FastlaneCore::PrintTable.print_values(config: Cert.config, hide_keys: [:output_path], title: "Summary for cert #{Fastlane::VERSION}")
+
+      login
+
+      should_create = Cert.config[:force]
+      unless should_create
+        cert_path = find_existing_cert
+        should_create = cert_path.nil?
+      end
+
+      return unless should_create
+
+      if create_certificate # no certificate here, creating a new one
+        return # success
+      else
+        UI.user_error!("Something went wrong when trying to create a new certificate...")
+      end
+    end
+
+    # Command method for the :revoke_expired sub-command
+    def revoke_expired_certs!
+      FastlaneCore::PrintTable.print_values(config: Cert.config, hide_keys: [:output_path], title: "Summary for cert #{Fastlane::VERSION}")
+
+      login
+
+      to_revoke = expired_certs
+
+      if to_revoke.empty?
+        UI.success "No expired certificates were found to revoke! 👍"
+        return
+      end
+
+      revoke_count = 0
+
+      to_revoke.each do |certificate|
+        begin
+          UI.message "#{certificate.id} #{certificate.name} has expired, revoking..."
+          certificate.revoke!
+          revoke_count += 1
+        rescue => e
+          UI.error "An error occurred while revoking #{certificate.id} #{certificate.name}"
+          UI.error "#{e.message}\n#{e.backtrace.join("\n")}" if $verbose
+        end
+      end
+
+      UI.success "#{revoke_count} expired certificate#{'s' if revoke_count != 1} #{revoke_count == 1 ? 'has' : 'have'} been revoked! 👍"
+    end
+
+    def expired_certs
+      certificates.select do |certificate|
+        certificate.expires < Time.now.utc
+      end
+    end
+
+    def find_existing_cert
+      certificates.each do |certificate|
+        unless certificate.can_download
+          next
+        end
+
+        path = store_certificate(certificate)
+        private_key_path = File.expand_path(File.join(Cert.config[:output_path], "#{certificate.id}.p12"))
+
+        if FastlaneCore::CertChecker.installed?(path)
+          # This certificate is installed on the local machine
+          ENV["CER_CERTIFICATE_ID"] = certificate.id
+          ENV["CER_FILE_PATH"] = path
+
+          UI.success "Found the certificate #{certificate.id} (#{certificate.name}) which is installed on the local machine. Using this one."
+
+          return path
+        elsif File.exist?(private_key_path)
+          keychain = File.expand_path(Cert.config[:keychain_path])
+          password = Cert.config[:keychain_password]
+          FastlaneCore::KeychainImporter.import_file(private_key_path, keychain, keychain_password: password)
+          FastlaneCore::KeychainImporter.import_file(path, keychain, keychain_password: password)
+
+          ENV["CER_CERTIFICATE_ID"] = certificate.id
+          ENV["CER_FILE_PATH"] = path
+
+          UI.success "Found the cached certificate #{certificate.id} (#{certificate.name}). Using this one."
+
+          return path
+        else
+          UI.error "Certificate #{certificate.id} (#{certificate.name}) can't be found on your local computer"
+        end
+
+        File.delete(path) # as apparantly this certificate is pretty useless without a private key
+      end
+
+      UI.important "Couldn't find an existing certificate... creating a new one"
+      return nil
+    end
+
+    # All certificates of this type
+    def certificates
+      certificate_type.all
+    end
+
+    # The kind of certificate we're interested in
+    def certificate_type
+      cert_type = Spaceship.certificate.production
+      cert_type = Spaceship.certificate.in_house if Spaceship.client.in_house?
+      cert_type = Spaceship.certificate.development if Cert.config[:development]
+
+      cert_type
+    end
+
+    def create_certificate
+      # Create a new certificate signing request
+      csr, pkey = Spaceship.certificate.create_certificate_signing_request
+
+      # Use the signing request to create a new distribution certificate
+      begin
+        certificate = certificate_type.create!(csr: csr)
+      rescue => ex
+        if ex.to_s.include?("You already have a current")
+          type_name = (Cert.config[:development] ? "Development" : "Distribution")
+          UI.user_error!("Could not create another #{type_name} certificate, reached the maximum number of available #{type_name} certificates.", show_github_issues: true)
+        end
+
+        raise ex
+      end
+
+      # Store all that onto the filesystem
+
+      request_path = File.expand_path(File.join(Cert.config[:output_path], "#{certificate.id}.certSigningRequest"))
+      File.write(request_path, csr.to_pem)
+
+      private_key_path = File.expand_path(File.join(Cert.config[:output_path], "#{certificate.id}.p12"))
+      File.write(private_key_path, pkey)
+
+      cert_path = store_certificate(certificate)
+
+      # Import all the things into the Keychain
+      keychain = File.expand_path(Cert.config[:keychain_path])
+      password = Cert.config[:keychain_password]
+      FastlaneCore::KeychainImporter.import_file(private_key_path, keychain, keychain_password: password)
+      FastlaneCore::KeychainImporter.import_file(cert_path, keychain, keychain_password: password)
+
+      # Environment variables for the fastlane action
+      ENV["CER_CERTIFICATE_ID"] = certificate.id
+      ENV["CER_FILE_PATH"] = cert_path
+
+      UI.success "Successfully generated #{certificate.id} which was imported to the local machine."
+
+      return cert_path
+    end
+
+    def store_certificate(certificate)
+      path = File.expand_path(File.join(Cert.config[:output_path], "#{certificate.id}.cer"))
+      raw_data = certificate.download_raw
+      File.write(path, raw_data)
+      return path
+    end
+  end
+end

data/credentials_manager/README.md

@@ -0,0 +1,62 @@
+CredentialsManager
+===================
+
+`CredentialsManager` is used by most components in the [fastlane.tools](https://fastlane.tools) toolchain.
+
+All code related to your username and password can be found here: [account_manager.rb](https://github.com/fastlane/fastlane/blob/master/credentials_manager/lib/credentials_manager/account_manager.rb)
+
+## Usage
+Along with the [Ruby libraries](https://github.com/fastlane/fastlane/tree/master/credentials_manager#implementing-a-custom-solution) you can use the command line interface to add credentials to the keychain.
+
+**Adding Credentials**
+```
+fastlane-credentials add --username felix@krausefx.com
+Password: *********
+Credential felix@krausefx.com:********* added to keychain.
+```
+
+**Removing Credentials**
+```
+fastlane-credentials remove --username felix@krausefx.com
+password has been deleted.
+```
+
+## Storing in the keychain
+
+By default, your Apple credentials are stored in the macOS Keychain.
+
+Your password is only stored locally on your computer.
+
+## Change Password
+
+You can easily delete the stored password by opening the "Keychain Access" app, switching to *All Items*, and searching for "*deliver*". Select the item you want to change and delete it. Next time running one of the tools, you'll be asked for the new password.
+
+## Using environment variables
+
+```
+FASTLANE_USER
+FASTLANE_PASSWORD
+```
+
+If you don't want to have your password stored in the Keychain use `FASTLANE_DONT_STORE_PASSWORD`.
+
+## Implementing a custom solution
+
+All ```fastlane``` tools are Ruby-based, and you can take a look at the source code to easily implement your own authentication solution.
+
+```ruby
+require 'credentials_manager'
+
+data = CredentialsManager::AccountManager.new(user: user, password: password)
+puts data.user
+puts data.password
+```
+
+# Code of Conduct
+Help us keep `fastlane` open and inclusive. Please read and follow our [Code of Conduct](https://github.com/fastlane/fastlane/blob/master/CODE_OF_CONDUCT.md).
+
+# License
+
+This project is licensed under the terms of the MIT license. See the LICENSE file.
+
+> This project and all fastlane tools are in no way affiliated with Apple Inc. This project is open source under the MIT license, which means you have full access to the source code and can modify it to fit your own needs. All fastlane tools run on your own computer or server, so your credentials or other sensitive information will never leave your own computer. You are responsible for how you use fastlane tools.

data/credentials_manager/lib/credentials_manager.rb

@@ -0,0 +1,12 @@
+require 'credentials_manager/account_manager'
+require 'credentials_manager/cli'
+require 'credentials_manager/appfile_config'
+
+# Third Party code
+require 'colored'
+require 'security'
+require 'highline/import' # to hide the entered password
+
+module CredentialsManager
+  ROOT = Pathname.new(File.expand_path('../..', __FILE__))
+end

data/credentials_manager/lib/credentials_manager/account_manager.rb

@@ -0,0 +1,104 @@
+require 'security'
+require 'highline/import' # to hide the entered password
+
+module CredentialsManager
+  class AccountManager
+    # @param prefix [String] Very optional, is used for the
+    #   iTunes Transporter which uses application specofic passwords
+    def initialize(user: nil, password: nil, prefix: nil)
+      @prefix = prefix || "deliver"
+
+      @user = user
+      @password = password
+    end
+
+    def user
+      @user ||= ENV["FASTLANE_USER"]
+      @user ||= ENV["DELIVER_USER"]
+      @user ||= AppfileConfig.try_fetch_value(:apple_id)
+      ask_for_login if @user.to_s.length == 0
+      return @user
+    end
+
+    def fetch_password_from_env
+      ENV["FASTLANE_PASSWORD"] || ENV["DELIVER_PASSWORD"]
+    end
+
+    def password(ask_if_missing: true)
+      @password ||= fetch_password_from_env
+      unless @password
+        item = Security::InternetPassword.find(server: server_name)
+        @password ||= item.password if item
+      end
+      ask_for_login while ask_if_missing && @password.to_s.length == 0
+      return @password
+    end
+
+    # Call this method to ask the user to re-enter the credentials
+    # @param force: if false the user is asked before it gets deleted
+    # @return: Did the user decide to remove the old entry and enter a new password?
+    def invalid_credentials(force: false)
+      puts "The login credentials for '#{user}' seem to be wrong".red
+
+      if fetch_password_from_env
+        puts "The password was taken from the environment variable"
+        puts "Please make sure it is correct"
+        return false
+      end
+
+      if force || agree("Do you want to re-enter your password? (y/n)", true)
+        puts "Removing Keychain entry for user '#{user}'...".yellow
+        remove_from_keychain
+        ask_for_login
+        return true
+      end
+      false
+    end
+
+    def add_to_keychain
+      Security::InternetPassword.add(server_name, user, password)
+    end
+
+    def remove_from_keychain
+      Security::InternetPassword.delete(server: server_name)
+      @password = nil
+    end
+
+    def server_name
+      "#{@prefix}.#{user}"
+    end
+
+    private
+
+    def ask_for_login
+      puts "-------------------------------------------------------------------------------------".green
+      puts "The login information you enter will be stored in your Mac OS Keychain".green
+      puts "You can also pass the password using the `FASTLANE_PASSWORD` environment variable".green
+      puts "More information about it on GitHub: https://github.com/fastlane/fastlane/tree/master/credentials_manager".green
+      puts "-------------------------------------------------------------------------------------".green
+
+      if @user.to_s.length == 0
+        raise "Missing username, and running in non-interactive shell" if $stdout.isatty == false
+        @user = ask("Username: ") while @user.to_s.length == 0
+        # we return here, as only the username was asked for now, we'll get called for the pw again anyway
+        return
+      end
+
+      while @password.to_s.length == 0
+        raise "Missing password for user #{@user}, and running in non-interactive shell" if $stdout.isatty == false
+        @password = ask("Password (for #{@user}): ") { |q| q.echo = "*" }
+      end
+
+      return true if ENV["FASTLANE_DONT_STORE_PASSWORD"]
+      return true if (/darwin/ =~ RUBY_PLATFORM).nil? # mac?, since we don't have access to the helper here
+
+      # Now we store this information in the keychain
+      if add_to_keychain
+        return true
+      else
+        puts "Could not store password in keychain".red
+        return false
+      end
+    end
+  end
+end