fastlane-plugin-match_keystore 0.1.9 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42c7915b7d46b87470d41acfd251257c04ce89460ac60a08318404530a1fbd24
-  data.tar.gz: 07f280f892d41adee35f025218da2a1eeb345f17c9cf27d2d027246f4b248940
+  metadata.gz: d5b1878b6e0f6453f4c62eab321b2080210dcaa93fafcb04b14ac9819e7f996e
+  data.tar.gz: 18748d40e3d7c6dbe63179c8bbc726b5284049c25349d28c5ad1e76d529c21de
 SHA512:
-  metadata.gz: 85ff5b2dda6f5a38714a09aea05fb279ec87015e970860ac3238f10280d233195936b84ef617d6bfafca36ee9d164f4a1c6267d8ea76e75305a40f4d44b55627
-  data.tar.gz: f8e3fba2336ef34b35300d38535d2f5fbb5798af9efc50f268fa33a7a05282157f1a46755953eac2d99b362642560b8dc9e7b6255377a13e0fae9b5ebcfcd60d
+  metadata.gz: 31e657e39efa81b9141182a75f8df3ee5cc1704a6b1ed2b8526d50ee1e361aaf7d74ed3b8a04771e323a215850051eba4b3f6f932c9808ec8cf57bc70ad894f7
+  data.tar.gz: 1dce9a11c73f7921cea57a5953b7b64b2497bb401864cc906386617f342f3792a8c360d81d6709c3538b4282b6e9462c3fb7d5a87b215cebaffc950448bf6d76

data/README.md

@@ -24,13 +24,18 @@ The keystore properties are encrypted with AES in order to secure sensitive data
 
 ```ruby
   lane :release_and_sign do |options|
-  	gradle(task: "clean")
+    gradle(task: "clean")
     gradle(task: 'assemble', build_type: 'Release')
 
     signed_apk_path = match_keystore(
       git_url: "https://github.com/<GITHUB_USERNAME>/keystores.git", # Please use a private Git repository !
       package_name: "com.your.package.name",
       apk_path: "/app/build/outputs/apk/app-release.apk" # Or path without APK: /app/build/outputs/apk/
+      # Optional:
+      match_secret: "A-very-str0ng-password!", # The secret use to encrypt/decrypt Keystore passwords on Git repo (for CI)
+      existing_keystore: "assets/existing-keystore.jks", # Optional, if needed to import an existing keystore
+      override_keystore: true, # Optional, override an existing Keystore on Git repo
+      keystore_data: "assets/keystore.json" # Optional, all data required to create a new Keystore (use to bypass prompt)
     )
 
     # Return the path of signed APK (useful for other lanes such as `publish_to_firebase`, `upload_to_play_store`)

data/lib/fastlane/plugin/match_keystore/actions/match_keystore_action.rb

@@ -1,6 +1,8 @@
 require 'fastlane/action'
 require 'fileutils'
 require 'os'
+require 'json'
+require 'digest'
 require_relative '../helper/match_keystore_helper'
 
 module Fastlane
@@ -13,6 +15,17 @@ module Fastlane
 
     class MatchKeystoreAction < Action
 
+      def self.to_md5(value)
+        hash_value = Digest::MD5.hexdigest value
+        hash_value
+      end
+
+      def self.load_json(json_path)
+        file = File.read(json_path)
+        data_hash = JSON.parse(file)
+        data_hash
+      end
+
       def self.load_properties(properties_filename)
         properties = {}
         File.open(properties_filename, 'r') do |properties_file|
@@ -42,7 +55,7 @@ module Fastlane
 
       def self.get_build_tools
         android_home = self.get_android_home()
-        build_tools_root = android_home + '/build-tools'
+        build_tools_root = File.join(android_home, '/build-tools')
 
         sub_dirs = Dir.glob(File.join(build_tools_root, '*', ''))
         build_tools_last_version = ''
@@ -62,40 +75,45 @@ module Fastlane
       end
 
       def self.gen_key(key_path, password)
-        `rm -f #{key_path}`
-        `echo "#{password}" | openssl dgst -sha512 | awk '{print $2}' | cut -c1-128 > #{key_path}`
+        `rm -f '#{key_path}'`
+        `echo "#{password}" | openssl dgst -sha512 | awk '{print $2}' | cut -c1-128 > '#{key_path}'`
       end
 
       def self.encrypt_file(clear_file, encrypt_file, key_path)
-        `rm -f #{encrypt_file}`
-        `openssl enc -aes-256-cbc -salt -pbkdf2 -in #{clear_file} -out #{encrypt_file} -pass file:#{key_path}`
+        `rm -f '#{encrypt_file}'`
+        `openssl enc -aes-256-cbc -salt -pbkdf2 -in '#{clear_file}' -out '#{encrypt_file}' -pass file:'#{key_path}'`
       end
 
       def self.decrypt_file(encrypt_file, clear_file, key_path)
-        `rm -f #{clear_file}`
-        `openssl enc -d -aes-256-cbc -pbkdf2 -in #{encrypt_file} -out #{clear_file} -pass file:#{key_path}`
+        `rm -f '#{clear_file}'`
+        `openssl enc -d -aes-256-cbc -pbkdf2 -in '#{encrypt_file}' -out '#{clear_file}' -pass file:'#{key_path}'`
       end
 
       def self.sign_apk(apk_path, keystore_path, key_password, alias_name, alias_password, zip_align)
 
         build_tools_path = self.get_build_tools()
+        UI.message("Build-tools path: #{build_tools_path}")
 
         # https://developer.android.com/studio/command-line/zipalign
         if zip_align == true
           apk_path_aligned = apk_path.gsub(".apk", "-aligned.apk")
-          `rm -f #{apk_path_aligned}`
-          `#{build_tools_path}zipalign 4 #{apk_path} #{apk_path_aligned}`
+          `rm -f '#{apk_path_aligned}'`
+          UI.message("Aligning APK (zipalign): #{apk_path_aligned}")
+          `#{build_tools_path}zipalign -f -v 4 '#{apk_path}' '#{apk_path_aligned}'`
         else
+          UI.message("No zip align!")
           apk_path_aligned = apk_path
         end
+        apk_path_signed = apk_path.gsub(".apk", "-signed.apk")
+        apk_path_signed = apk_path_signed.gsub("unsigned", "")
+        apk_path_signed = apk_path_signed.gsub("--", "-")
 
         # https://developer.android.com/studio/command-line/apksigner
-        apk_path_signed = apk_path.gsub(".apk", "-signed.apk")
-        `rm -f #{apk_path_signed}`
-        `#{build_tools_path}apksigner sign --ks #{keystore_path} --ks-key-alias '#{alias_name}' --ks-pass pass:'#{alias_password}' --key-pass pass:'#{key_password}' --v1-signing-enabled true --v2-signing-enabled true --out #{apk_path_signed} #{apk_path_aligned}`
-    
-        `#{build_tools_path}apksigner verify #{apk_path_signed}`
-        `rm -f #{apk_path_aligned}`
+        `rm -f '#{apk_path_signed}'`
+        `#{build_tools_path}apksigner sign --ks '#{keystore_path}' --ks-key-alias '#{alias_name}' --ks-pass pass:'#{key_password}' --key-pass pass:'#{alias_password}' --v1-signing-enabled true --v2-signing-enabled true --out '#{apk_path_signed}' '#{apk_path_aligned}'`
+        
+        `#{build_tools_path}apksigner verify '#{apk_path_signed}'`
+        `rm -f '#{apk_path_aligned}'`
 
         apk_path_signed
       end
@@ -107,6 +125,11 @@ module Fastlane
 
       def self.resolve_apk_path(apk_path)
 
+        # Set default APK path if not set:
+        if apk_path.to_s.strip.empty?
+          apk_path = '/app/build/outputs/apk/'
+        end
+
         if !apk_path.to_s.end_with?(".apk") 
 
           if !File.directory?(apk_path)
@@ -134,15 +157,28 @@ module Fastlane
         apk_path
       end
 
+      def self.prompt2(params)
+        # UI.message("prompt2: #{params[:value]}")
+        if params[:value].to_s.empty?
+          return_value = other_action.prompt(text: params[:text], secure_text: params[:secure_text], ci_input: params[:ci_input])
+        else
+          return_value = params[:value]
+        end
+        return_value
+      end
+
       def self.run(params)
 
+        # Get input parameters:
         git_url = params[:git_url]
         package_name = params[:package_name]
         apk_path = params[:apk_path]
         existing_keystore = params[:existing_keystore]
-        ci_password = params[:ci_password]
+        match_secret = params[:match_secret]
         override_keystore = params[:override_keystore]
+        keystore_data = params[:keystore_data]
 
+        # Init constants:
         keystore_name = 'keystore.jks'
         properties_name = 'keystore.properties'
         keystore_info_name = 'keystore.txt'
@@ -158,52 +194,83 @@ module Fastlane
         # Check OpenSSL:
         self.check_openssl_version
 
+        # Init workign local directory:
         dir_name = ENV['HOME'] + '/.match_keystore'
         unless File.directory?(dir_name)
           UI.message("Creating '.match_keystore' working directory...")
           FileUtils.mkdir_p(dir_name)
         end
 
-        key_path = dir_name + '/key.hex'
+        # Init 'security password' for AES encryption:
+        key_name = "#{self.to_md5(git_url)}.hex"
+        key_path = File.join(dir_name, key_name)
+        # UI.message(key_path)
         if !File.file?(key_path)
-          security_password = other_action.prompt(text: "Security password: ", secure_text: true, ci_input: ci_password)
+          security_password = self.prompt2(text: "Security password: ", secure_text: true, value: match_secret)
           if security_password.to_s.strip.empty?
-            raise "Security password is not defined! Please use 'ci_password' parameter for CI."
+            raise "Security password is not defined! Please use 'match_secret' parameter for CI."
           end
-          UI.message "Generating security key..."
+          UI.message "Generating security key '#{key_name}'..."
           self.gen_key(key_path, security_password)
         end
 
+        # Check is 'security password' is well initialized:
         tmpkey = self.get_file_content(key_path).strip
         if tmpkey.length == 128
-          UI.message "Security key initialized"
+          UI.message "Security key '#{key_name}' initialized"
         else
-          raise "The security key format is invalid, or not initialized!"
+          raise "The security key '#{key_name}' is malformed, or not initialized!"
         end
 
-        repo_dir = dir_name + '/repo'
+        # Create repo directory to sync remote Keystores repository:
+        repo_dir = File.join(dir_name, self.to_md5(git_url))
+        # UI.message(repo_dir)
         unless File.directory?(repo_dir)
           UI.message("Creating 'repo' directory...")
           FileUtils.mkdir_p(repo_dir)
         end
 
-        gitDir = repo_dir + '/.git'
-        unless File.directory?(gitDir)
+        # Cloning/pulling GIT remote repository:
+        gitDir = File.join(repo_dir, '/.git')
+        if !File.directory?(gitDir)
           UI.message("Cloning remote Keystores repository...")
           puts ''
           `git clone #{git_url} #{repo_dir}`
           puts ''
+        else
+          UI.message("Pulling remote Keystores repository...")
+          puts ''
+          `cd #{repo_dir} && git pull`
+          puts ''
         end
 
-        keystoreAppDir = repo_dir + '/' + package_name
+        # Create sub-directory for Android app:
+        if package_name.to_s.strip.empty?
+          raise "Package name is not defined!"
+        end
+        keystoreAppDir = File.join(repo_dir, package_name)
         unless File.directory?(keystoreAppDir)
           UI.message("Creating '#{package_name}' keystore directory...")
           FileUtils.mkdir_p(keystoreAppDir)
         end
 
-        keystore_path = keystoreAppDir + '/' + keystore_name
-        properties_path = keystoreAppDir + '/' + properties_name
-        properties_encrypt_path = keystoreAppDir + '/' + properties_encrypt_name
+        keystore_path = File.join(keystoreAppDir, keystore_name)
+        properties_path = File.join(keystoreAppDir, properties_name)
+        properties_encrypt_path = File.join(keystoreAppDir, properties_encrypt_name)
+
+        # Load parameters from JSON for CI or Unit Tests:
+        if keystore_data != nil && File.file?(keystore_data)
+          data_json = self.load_json(keystore_data)
+          data_key_password = data_json['key_password']
+          data_alias_name = data_json['alias_name']
+          data_alias_password = data_json['alias_password']
+          data_full_name = data_json['full_name']
+          data_org_unit = data_json['org_unit']
+          data_org = data_json['org']
+          data_city_locality = data_json['city_locality']
+          data_state_province = data_json['state_province']
+          data_country = data_json['country']
+        end
 
         # Create keystore with command
         override_keystore = !existing_keystore.to_s.strip.empty? && File.file?(existing_keystore)
@@ -213,15 +280,15 @@ module Fastlane
             FileUtils.remove_dir(keystore_path)
           end
 
-          key_password = other_action.prompt(text: "Keystore Password: ")
+          key_password = self.prompt2(text: "Keystore Password: ", value: data_key_password)
           if key_password.to_s.strip.empty?
             raise "Keystore Password is not definined!"
           end
-          alias_name = other_action.prompt(text: "Keystore Alias name: ")
+          alias_name = self.prompt2(text: "Keystore Alias name: ", value: data_alias_name)
           if alias_name.to_s.strip.empty?
             raise "Keystore Alias name is not definined!"
           end
-          alias_password = other_action.prompt(text: "Keystore Alias password: ")
+          alias_password = self.prompt2(text: "Keystore Alias password: ", value: data_alias_password)
           if alias_password.to_s.strip.empty?
             raise "Keystore Alias password is not definined!"
           end
@@ -230,20 +297,20 @@ module Fastlane
           if !File.file?(existing_keystore)
             UI.message("Generating Android Keystore...")
             
-            full_name = other_action.prompt(text: "Certificate First and Last Name: ")
-            org_unit = other_action.prompt(text: "Certificate Organisation Unit: ")
-            org = other_action.prompt(text: "Certificate Organisation: ")
-            city_locality = other_action.prompt(text: "Certificate City or Locality: ")
-            state_province = other_action.prompt(text: "Certificate State or Province: ")
-            country = other_action.prompt(text: "Certificate Country Code (XX): ")
+            full_name = self.prompt2(text: "Certificate First and Last Name: ", value: data_full_name)
+            org_unit = self.prompt2(text: "Certificate Organisation Unit: ", value: data_org_unit)
+            org = self.prompt2(text: "Certificate Organisation: ", value: data_org)
+            city_locality = self.prompt2(text: "Certificate City or Locality: ", value: data_city_locality) 
+            state_province = self.prompt2(text: "Certificate State or Province: ", value: data_state_province)
+            country = self.prompt2(text: "Certificate Country Code (XX): ", value: data_country)
             
             keytool_parts = [
               "keytool -genkey -v",
-              "-keystore #{keystore_path}",
-              "-alias #{alias_name}",
+              "-keystore '#{keystore_path}'",
+              "-alias '#{alias_name}'",
               "-keyalg RSA -keysize 2048 -validity 10000",
-              "-storepass #{alias_password} ",
-              "-keypass #{key_password}",
+              "-storepass '#{alias_password}'",
+              "-keypass '#{key_password}'",
               "-dname \"CN=#{full_name}, OU=#{org_unit}, O=#{org}, L=#{city_locality}, S=#{state_province}, C=#{country}\"",
             ]
             sh keytool_parts.join(" ")
@@ -258,6 +325,7 @@ module Fastlane
             FileUtils.remove_dir(properties_path)
           end
         
+          # Build URL:
           store_file = git_url + '/' + package_name + '/' + keystore_name
 
           out_file = File.new(properties_path, "w")
@@ -271,15 +339,17 @@ module Fastlane
           File.delete(properties_path)
 
           # Print Keystore data in repo:
-          keystore_info_path = keystoreAppDir + '/' + keystore_info_name
-          `yes "" | keytool -list -v -keystore #{keystore_path} > #{keystore_info_path}`
+          keystore_info_path = File.join(keystoreAppDir, keystore_info_name)
+          `yes "" | keytool -list -v -keystore '#{keystore_path}' -storepass '#{key_password}' > '#{keystore_info_path}'`
           
           UI.message("Upload new Keystore to remote repository...")
-          `cd #{repo_dir} && git add .`
-          `cd #{repo_dir} && git commit -m "[ADD] Keystore for app '#{package_name}'."`
-          `cd #{repo_dir} && git push`
+          puts ''
+          `cd '#{repo_dir}' && git add .`
+          `cd '#{repo_dir}' && git commit -m "[ADD] Keystore for app '#{package_name}'."`
+          `cd '#{repo_dir}' && git push`
+          puts ''
 
-        else
+        else  
           UI.message "Keystore file already exists, continue..."
 
           self.decrypt_file(properties_encrypt_path, properties_path, key_path)
@@ -290,37 +360,40 @@ module Fastlane
           alias_password = properties['aliasPassword']
 
           File.delete(properties_path)
-
         end
 
+        # Resolve path to the APK to sign:
         output_signed_apk = ''
         apk_path = self.resolve_apk_path(apk_path)
 
+        # Sign APK:
         if File.file?(apk_path)
           UI.message("APK to sign: " + apk_path)
 
           if File.file?(keystore_path)
 
             UI.message("Signing the APK...")
+            puts ''
             output_signed_apk = self.sign_apk(
               apk_path, 
               keystore_path, 
               key_password, 
               alias_name, 
               alias_password, 
-              true
+              true # Zip align
             )
+            puts ''
           end 
         else
           UI.message("No APK file found to sign!")
         end
 
+        # Prepare contect shared values for next lanes:
         Actions.lane_context[SharedValues::MATCH_KEYSTORE_PATH] = keystore_path
         Actions.lane_context[SharedValues::MATCH_KEYSTORE_ALIAS_NAME] = alias_name
         Actions.lane_context[SharedValues::MATCH_KEYSTORE_APK_SIGNED] = output_signed_apk
 
         output_signed_apk
-
       end
 
       def self.description
@@ -363,11 +436,11 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :apk_path,
                                    env_name: "MATCH_KEYSTORE_APK_PATH",
                                 description: "Path of the APK file to sign",
-                                   optional: false,
+                                   optional: true,
                                        type: String),
-          FastlaneCore::ConfigItem.new(key: :ci_password,
-                                   env_name: "MATCH_KEYSTORE_CI_PASSWORD",
-                                description: "Password to decrypt keystore.properties file (CI)",
+          FastlaneCore::ConfigItem.new(key: :match_secret,
+                                   env_name: "MATCH_KEYSTORE_SECRET",
+                                description: "Secret to decrypt keystore.properties file (CI)",
                                    optional: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :existing_keystore,
@@ -379,7 +452,12 @@ module Fastlane
                                    env_name: "MATCH_KEYSTORE_OVERRIDE",
                                 description: "Override an existing Keystore (false by default)",
                                    optional: true,
-                                       type: Boolean)
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :keystore_data,
+                                   env_name: "MATCH_KEYSTORE_JSON_PATH",
+                                description: "Required data to import an existing keystore, or create a new one",
+                                   optional: true,
+                                       type: String)
         ]
       end
 

data/lib/fastlane/plugin/match_keystore/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module MatchKeystore
-    VERSION = "0.1.9"
+    VERSION = "0.1.14"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-match_keystore
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.14
 platform: ruby
 authors:
 - Christopher NEY
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-11 00:00:00.000000000 Z
+date: 2020-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -167,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Easily sync your Android keystores across your team