secure-keys 1.1.2 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cd5c377f201fdb4fd22802645629371e0846768d444398b5fc8de07152edb58
-  data.tar.gz: 845e7fb862ec80987753479bfba9b978336c3090123c41b7dac765ec20a1465b
+  metadata.gz: cdab80c05ee6ac029d64ec53aef700bc77e9126398f886f6fc7e0ae529297535
+  data.tar.gz: 38176c478f562dfcacd51e62b051f49705cec3cc66a586e20487038965a9976e
 SHA512:
-  metadata.gz: 301b39d752b908b2f8817223a74ee84d8f08a9e3da3f7c41be022d03f392af2a0cb0dd2a320ed73e0c643536826606dad87a9c384da4c3c58c2e2e1af8149c6c
-  data.tar.gz: bd83843339d9169c06e80e31ed3b0fb98f574cd2367001158e668ae38534cc287f8f959b57fbadf343da89e9ddd216f89952c2289a489a9843dbd6ab2bff80ba
+  metadata.gz: 77e197f322a085f56ce57eef897fdcc156c2c5fe3be9decd1464b396080cfbab2acb39def1787c872b7980c8fb6b9530b6487ccbd2b8b87e93beff57a64f1d51
+  data.tar.gz: ffc4ba7aedeff64d0d30f214564b2ec48f4658d4a5eef8e428877b7d98ab896d5a108e0a9e50bdd9668cfa62496d0b9929b6efab50f42814ff4ae1871dc22b14

data/README.md

@@ -1,5 +1,5 @@
 <div style="display: flex; gap: 10px; padding-bottom: 20px;">
-  <img src="https://img.shields.io/badge/version-1.0.0-cyan" alt="Keys Version 1.0.0">
+  <img src="https://img.shields.io/badge/version-1.1.4-cyan" alt="SecureKeys version">
 
   <img src="https://img.shields.io/badge/iOS-^13.0-blue" alt="iOS version 13.0">
 
@@ -138,8 +138,11 @@ secure-keys --help
 Usage: secure-keys [--options]
 
     -h, --help                       Use the provided commands to select the params
+        --xcframework                Add the xcframework to the target
     -d, --delimiter DELIMITER        The delimiter to use for the key access (default: ",")
+        --[no-]generate              Generate the SecureKeys.xcframework
     -i, --identifier IDENTIFIER      The identifier to use for the key access (default: "secure-keys")
+        --verbose                    Enable verbose mode (default: false)
     -v, --version                    Show the secure-keys version
 ```
 
@@ -165,16 +168,16 @@ import SecureKeys
 // Using key directly in the code
 let apiKey = SecureKey.apiKey.decryptedValue
 
-// Using key from `Key` enum
+// Using key from `SecureKey` enum
 let someKey: String = key(for: .someKey)
 
-// Alternative way to use key from `Key` enum
+// Alternative way to use key from `SecureKey` enum
 let someKey: String = key(.someKey)
 
-// Using raw value from `Key` enum
+// Using raw value from `SecureKey` enum
 let apiKey: SecureKey = "apiKey".secretKey
 
-// Using raw value from `Key` enum with decrypted value
+// Using raw value from `SecureKey` enum with decrypted value
 let apiKey: String = "apiKey".secretKey.decryptedValue
 
 // Using `key` method to get the key
@@ -183,6 +186,73 @@ let apiKey: String = .key(for: .apiKey)
 
 ## How to install the `SecureKeys.xcframework` in the iOS project
 
+### Automatically
+
+> [!IMPORTANT]
+> You can see more information about the command using the `--help` option.
+
+```bash
+secure-keys --xcframework --help
+
+# Output
+Usage: secure-keys --xcframework [--options]
+
+    -h, --help                       Use the provided commands to select the params
+        --[no-]add                   Add the SecureKeys XCFramework to the Xcode project (default: true)
+    -t, --target TARGET              The target to add the xcframework
+    -r, --replace                    Replace the existing xcframework in the Xcode project (default: false)
+    -x, --xcodeproj XCODEPROJ        The Xcode project path (default: the first found Xcode project)
+```
+
+From the `secure-keys` command, you can use the `--xcframework` option to add the `SecureKeys.xcframework` to the iOS project.
+
+```bash
+secure-keys --xcframework --target "YourTargetName" --add
+```
+
+If you want to add the `SecureKeys.xcframework` to an iOS that already contains the `SecureKeys` source code, you can use the `--replace` option.
+
+```bash
+secure-keys --xcframework --target "YourTargetName" --replace
+```
+
+> [!IMPORTANT]
+> If you don't need to generate the `SecureKeys.xcframework` every time, you can use the `--no-generate` option.
+
+```bash
+secure-keys --no-generate --xcframework --target "YourTargetName"
+```
+
+Also, you can specify your Xcode project path using the `--xcodeproj` option.
+
+```bash
+secure-keys --xcframework --target "YourTargetName" --xcodeproj "/path/to/your/project.xcodeproj"
+```
+
+> [!IMPORTANT]
+> By default, the xcodeproj path would be the first found Xcode project.
+
+If you don't want to use the CLI options, you can configure some env variable to interact with the `secure-keys` command.
+
+```bash
+# e.g (Large version)
+export SECURE_KEYS_XCFRAMEWORK_TARGET="YourTargetName"
+export SECURE_KEYS_XCFRAMEWORK_ADD=true
+export SECURE_KEYS_XCFRAMEWORK_REPLACE=true
+export SECURE_KEYS_XCFRAMEWORK_XCODEPROJ="/path/to/your/project.xcodeproj"
+
+# e.g (Short version)
+export XCFRAMEWORK_TARGET="YourTargetName"
+export XCFRAMEWORK_ADD=true
+export XCFRAMEWORK_REPLACE=true
+export XCFRAMEWORK_XCODEPROJ="/path/to/your/project.xcodeproj"
+
+# Run the command
+secure-keys --xcframework
+```
+
+### Manually
+
 1. From the iOS project, click on the project target, select the `General` tab, and scroll down to the `Frameworks, Libraries, and Embedded Content` section.
 
 ![Project Target](/docs/assets/add-xcframework-to-ios-project/first-step.png)

data/bin/secure-keys

@@ -5,4 +5,4 @@ require 'dotenv/load'
 require_relative '../lib/keys'
 
 # Generate the keys
-SecureKeys::Generator.new.setup
+SecureKeys.run

data/lib/core/console/arguments/handler.rb

@@ -10,18 +10,37 @@ module SecureKeys
           # Configure the default arguments
           @arguments = {
             delimiter: nil,
+            generate: true,
             identifier: nil,
+            verbose: false,
           }
 
           # Fetch the argument value by key
           # from CLI arguments or environment variables
           #
-          # @param key [Symbol] the argument key
+          # @param key [Array|Symbol] the argument key
           # @param default [String] the default value
           #
           # @return [String] the argument value
           def self.fetch(key:, default: nil)
-            @arguments[key.to_sym] || ENV.fetch("secure_keys_#{key}".upcase, nil) || default
+            keys = Array(key).map(&:to_sym)
+            joined_keys = keys.join('_').upcase
+            @arguments.dig(*keys) || ENV["SECURE_KEYS_#{joined_keys}"] || ENV[joined_keys] || default
+          end
+
+          # Set the value of the key
+          # @param key [Symbol] the key to be updated
+          # @param value [String] the value to be updated
+          def self.set(key:, value:)
+            @arguments[key.to_sym] = value
+          end
+
+          # Append the argument value by key
+          # @param key [Symbol] the argument key
+          # @param value [String] the argument value
+          def self.deep_merge(key:, value:)
+            @arguments[key.to_sym] ||= {} # Initialize the key if it doesn't exist
+            @arguments[key.to_sym].merge!(value)
           end
         end
       end

data/lib/core/console/arguments/parser.rb

@@ -3,6 +3,7 @@
 require 'optparse'
 require_relative '../../globals/globals'
 require_relative './handler'
+require_relative './xcframework/parser'
 
 module SecureKeys
   module Core
@@ -16,7 +17,8 @@ module SecureKeys
 
             # Configure the arguement parser
             configure!
-            parse!(into: Handler.arguments)
+            order!(into: Handler.arguments)
+            configure_sub_arguments
           end
 
           private
@@ -28,14 +30,25 @@ module SecureKeys
               exit(0)
             end
 
+            on('--xcframework', 'Add the xcframework to the target') do
+              XCFramework::Parser.new
+            end
+
             on('-d', '--delimiter DELIMITER', String, "The delimiter to use for the key access (default: \"#{Globals.default_key_delimiter}\")")
+            on('--[no-]generate', TrueClass, 'Generate the SecureKeys.xcframework')
             on('-i', '--identifier IDENTIFIER', String, "The identifier to use for the key access (default: \"#{Globals.default_key_access_identifier}\")")
+            on('--verbose', TrueClass, 'Enable verbose mode (default: false)')
 
             on('-v', '--version', 'Show the secure-keys version') do
               puts "secure-keys version: v#{SecureKeys::VERSION}"
               exit(0)
             end
           end
+
+          # Configure the sub arguments
+          def configure_sub_arguments
+            Handler.set(key: :xcframework, value: XCFramework::Handler.arguments)
+          end
         end
       end
     end

data/lib/core/console/arguments/xcframework/handler.rb

@@ -0,0 +1,23 @@
+module SecureKeys
+  module Core
+    module Console
+      module Argument
+        module XCFramework
+          class Handler
+            class << self
+              attr_reader :arguments
+            end
+
+            # Configure the default arguments
+            @arguments = {
+              add: true,
+              replace: false,
+              target: nil,
+              xcodeproj: nil,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/console/arguments/xcframework/parser.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require_relative '../../../globals/globals'
+require_relative './handler'
+
+module SecureKeys
+  module Core
+    module Console
+      module Argument
+        module XCFramework
+          class Parser < OptionParser
+            # Initialize the argument parser with the default options
+            def initialize
+              super('Usage: secure-keys --xcframework [--options]')
+              separator('')
+
+              # Configure the arguement parser
+              configure!
+              order!(into: Handler.arguments)
+            end
+
+            private
+
+            # Configure the argument parser
+            def configure!
+              on('-h', '--help', 'Use the provided commands to select the params') do
+                puts self
+                exit(0)
+              end
+
+              on('--[no-]add', TrueClass, 'Add the SecureKeys XCFramework to the Xcode project (default: true)')
+              on('-t', '--target TARGET', String, 'The target to add the xcframework')
+              on('-r', '--replace', TrueClass, 'Replace the existing xcframework in the Xcode project (default: false)')
+              on('-x', '--xcodeproj XCODEPROJ', String, 'The Xcode project path (default: the first found Xcode project)')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/console/logger.rb

@@ -0,0 +1,123 @@
+require 'colorize'
+require 'logger'
+require 'tty-screen'
+require_relative '../globals/globals'
+
+module SecureKeys
+  module Core
+    module Console
+      module Logger
+        module_function
+
+        # Log a success message
+        # @param message [String] the message to log
+        def success(message:)
+          logger.info(message.to_s.green)
+        end
+
+        # Log an error message
+        # @param message [String] the message to log
+        def error(message:)
+          logger.warn(message.to_s.red)
+        end
+
+        # Log an important message
+        # @param message [String] the message to log
+        def important(message:)
+          logger.info(message.to_s.blue)
+        end
+
+        # Log a warning message
+        # @param message [String] the message to log
+        def warning(message:)
+          logger.info(message.to_s.yellow)
+        end
+
+        # Log a message without any formatting
+        # @param message [String] the message to log
+        def message(message:)
+          logger.info(message.to_s)
+        end
+
+        # Log a deprecated message
+        # @param message [String] the message to log
+        def deprecated(message:)
+          logger.error(message.to_s.deprecated)
+        end
+
+        # Log a command message
+        # @param command [String] the command to log
+        def command(command:)
+          logger.info("$ #{command}".cyan)
+        end
+
+        # Log a verbose message
+        # @param message [String] the message to log
+        def verbose(message:)
+          logger.debug(message.to_s) if Globals.verbose?
+        end
+
+        # Crash the terminal with a message
+        # @param message [String] the message to log
+        def crash!(message:)
+          raise(StandardError.new, message)
+        end
+
+        # Kill the terminal with a message
+        # @param message [String] the message to log
+        def kill!(message:)
+          error(message:)
+          exit(1)
+        end
+
+        # Log a command output
+        # @param command [String] the command to log
+        def command_output(command:)
+          actual = encode_as_utf_8_if_possible(message: command).split("\r")
+                                                                .last || ''
+          actual.split("\n").each do |cmd|
+            prefix = cmd.include?('▸') ? '' : '▸ '
+            logger.info("#{prefix} #{cmd.magenta}")
+          end
+        end
+
+        # Create a logger instance if needed
+        # @return [Logger] the logger instance
+        def logger
+          return @log unless @log.nil?
+
+          $stdout.sync = true
+          @log ||= ::Logger.new($stdout)
+          @log.formatter = proc do |severity, datetime, _, message|
+            "#{format_string(datetime:, severity:)} #{message}\n"
+          end
+
+          @log
+        end
+
+        # Format the log string
+        # @param datetime [Time] the datetime to format
+        # @param severity [String] the severity of the log
+        # @return [String] the formatted string
+        def format_string(datetime: Time.now, severity: '')
+          return "#{severity} [#{datetime.strftime('%Y-%m-%d %H:%M:%S.%2N')}]: " if Globals.verbose?
+
+          "[#{datetime.strftime('%H:%M:%S')}]: "
+        end
+
+        # Encode a message as UTF-8 if possible
+        # @param message [String] the message to encode
+        # @return [String] the encoded message
+        def encode_as_utf_8_if_possible(message:)
+          return message if message.valid_encoding?
+
+          return message.encode(Encoding::UTF_8, Encoding::UTF_16) if message.dup
+                                                                             .force_encoding(Encoding::UTF_16)
+                                                                             .valid_encoding?
+
+          message.encode(Encoding::UTF_8, invalid: :replace)
+        end
+      end
+    end
+  end
+end

data/lib/core/console/shell.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'open3'
+require_relative './logger'
+require_relative '../globals/globals'
+
+module SecureKeys
+  module Core
+    module Console
+      module Shell
+        module_function
+
+        # Source: https://github.com/fastlane/fastlane/blob/5b2106db41be2ca272dfe5b99360f29879c707bb/fastlane/lib/fastlane/helper/sh_helper.rb#L28
+        # Executes a shell command
+        # All commands will be executed in the given block
+        # @param command [String] The command that should be executed
+        # @param error_handler [Block] A block that will be called with the output of the command if the command exists with a non-zero exit status
+        # @return [Array] An array containing the output of the command, the exit status and the command
+        def sh(command:, error_handler: nil)
+          previous_encoding = [Encoding.default_external, Encoding.default_internal]
+          Encoding.default_external = Encoding::UTF_8
+          Encoding.default_internal = Encoding::UTF_8
+          Logger.command(command:)
+
+          output = ''
+          exit_status = nil
+          Open3.popen2e(command) do |_stdin, io, thread|
+            io.sync = true
+            io.each do |line|
+              Logger.command_output(command: line.strip)
+              output << line
+            end
+            exit_status = thread.value
+          end
+
+          if exit_status.exitstatus.zero?
+            output << command
+          else
+            message = "Exit status of command '#{command}' was #{exit_status.exitstatus} instead of 0.\n#{output}"
+
+            if error_handler || block_given?
+              Logger.error(message:)
+              error_handler&.call(output)
+            else
+              Logger.crash!(message:)
+            end
+          end
+
+          return yield(exit_status || $CHILD_STATUS, output, command) if block_given?
+
+          [output, exit_status || $CHILD_STATUS, command]
+        rescue StandardError => e
+          raise e
+        ensure
+          Encoding.default_external = previous_encoding.first
+          Encoding.default_internal = previous_encoding.last
+        end
+      end
+    end
+  end
+end

data/lib/core/environment/ci.rb

@@ -8,19 +8,10 @@ module SecureKeys
         # @param key [String] the key of the environment variable to fetch
         # @return [String] the value of the environment variable
         def fetch(key:)
-          ENV[formatted_key(key:)]
+          ENV[key]
         rescue StandardError
           puts "❌ Error fetching the key: #{key} from ENV variables"
         end
-
-        private
-
-        # Formats the key to match the format of the environment variables.
-        # @param key [String] the key to format
-        # @return [String] the formatted key
-        def formatted_key(key:)
-          key.gsub('-', '_').uppercase
-        end
       end
     end
   end

data/lib/core/generator.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+require_relative './globals/globals'
+require_relative './environment/ci'
+require_relative './environment/keychain'
+require_relative './utils/swift/writer'
+require_relative './utils/swift/package'
+require_relative './utils/swift/swift'
+require_relative './utils/swift/xcframework'
+require_relative './utils/openssl/cipher'
+
+module SecureKeys
+  module Core
+    class Generator
+      private
+
+      attr_accessor :cipher, :secrets_source, :secret_keys, :mapped_keys, :xcframework
+
+      public
+
+      def initialize
+        # Configure cipher
+        self.cipher = OpenSSL::Cipher.new
+        self.secrets_source = Globals.secret_keys_source
+
+        # Define the keys that we want to map
+        self.secret_keys = secrets_source.fetch(key: Globals.key_access_identifier)
+                                         .to_s
+                                         .split(Globals.key_delimiter)
+                                         .map(&:strip)
+
+        # Add the keys that we want to map
+        self.mapped_keys = secret_keys.map do |key|
+          encrypted_data = cipher.encrypt(value: secrets_source.fetch(key:))
+          { name: key.camelize, **encrypted_data }
+        end
+
+        # Configure the XCFramework
+        self.xcframework = Swift::XCFramework.new
+      end
+
+      def generate
+        if Globals.generate_xcframework?
+          pre_actions
+          generate_swift_package
+          write_keys
+          xcframework.generate
+        end
+
+        xcframework.configure_xcframework_to_xcodeproj
+        post_actions if Globals.generate_xcframework?
+      end
+
+      private
+
+      def generate_swift_package
+        package = Swift::Package.new
+        package.generate
+      end
+
+      def write_keys
+        writer = Swift::Writer.new(mapped_keys:,
+                                   secure_key_bytes: cipher.secure_key_bytes)
+        writer.write
+      end
+
+      def pre_actions
+        # Remove the keys directory
+        system("rm -rf #{Swift::KEYS_DIRECTORY}")
+      end
+
+      def post_actions
+        # Remove the keys directory
+        system("rm -rf #{Swift::SWIFT_PACKAGE_DIRECTORY}")
+
+        # Remove the build directory
+        system("rm -rf #{Swift::KEYS_DIRECTORY}/#{Swift::BUILD_DIRECTORY}")
+      end
+    end
+  end
+end

data/lib/core/globals/globals.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require_relative '../console/arguments/handler'
+require_relative '../utils/swift/swift'
 
 module SecureKeys
   module Globals
@@ -14,7 +15,7 @@ module SecureKeys
 
       # Check for Jenkins, Travis CI, ... environment variables
       %w[JENKINS_HOME JENKINS_URL TRAVIS CI APPCENTER_BUILD_ID TEAMCITY_VERSION GO_PIPELINE_NAME bamboo_buildKey GITLAB_CI XCS TF_BUILD GITHUB_ACTION GITHUB_ACTIONS BITRISE_IO BUDDY CODEBUILD_BUILD_ARN].any? do |current|
-        ENV[current].to_s.eql?('true')
+        ENV[current].to_s.to_boolean
       end
     end
 
@@ -24,6 +25,59 @@ module SecureKeys
       ENV.key?('CIRCLECI')
     end
 
+    # Check if the current instance is verbose
+    # @return [Bool] true if the current instance is verbose
+    def verbose?
+      Core::Console::Argument::Handler.fetch(key: :verbose)
+                                      .to_s
+                                      .to_boolean
+    end
+
+    # Check if the SecureKeys XCFramework should be generated
+    # @return [Bool] true if the SecureKeys XCFramework should be generated
+    def generate_xcframework?
+      Core::Console::Argument::Handler.fetch(key: :generate)
+                                      .to_s
+                                      .to_boolean
+    end
+
+    # Check if the SecureKeys XCFramework should be replaced
+    # @return [Bool] true if the SecureKeys XCFramework should be replaced
+    def replace_xcframework?
+      Core::Console::Argument::Handler.fetch(key: %i[xcframework replace])
+                                      .to_s
+                                      .to_boolean
+    end
+
+    # Check if the SecureKeys XCFramework should be added
+    # @return [Bool] true if the SecureKeys XCFramework should be added
+    def add_xcframework?
+      Core::Console::Argument::Handler.fetch(key: %i[xcframework add])
+                                      .to_s
+                                      .to_boolean
+    end
+
+    # Returns the Xcode project path
+    # @return [String] Xcode project path
+    def xcodeproj_path
+      Core::Console::Argument::Handler.fetch(key: %i[xcframework xcodeproj],
+                                             default: Dir.glob('**/*.xcodeproj').first)
+    end
+
+    # Returns the secure keys XCFramework path
+    # @return [String] secure keys XCFramework path
+    def secure_keys_xcframework_path
+      Dir.glob("**/#{Swift::KEYS_DIRECTORY}/#{Swift::XCFRAMEWORK_DIRECTORY}").first
+    end
+
+    # Determine the secret keys source based on the environment
+    # @return [Object] secret keys source
+    def secret_keys_source
+      return SecureKeys::Core::Environment::CI.new if ci?
+
+      SecureKeys::Core::Environment::Keychain.new
+    end
+
     # Returns the supported iOS platforms
     # @return [Array] supported iOS platforms
     def ios_platforms

data/lib/core/utils/extensions/kernel.rb

@@ -0,0 +1,13 @@
+require_relative './string/to_bool'
+require_relative './string/camelize'
+
+module Kernel
+  include BooleanCasting
+  include Camelize
+
+  String.include(BooleanCasting)
+  String.singleton_class.include(BooleanCasting)
+
+  String.include(Camelize)
+  String.singleton_class.include(Camelize)
+end

data/lib/core/utils/extensions/string/camelize.rb

@@ -0,0 +1,11 @@
+# Adds some useful methods to the String class
+module Camelize
+  # Convert a string to camel case format
+  # @return [String] the camel case formatted string
+  def camelize
+    words = split(/(?<=[a-z])(?=[A-Z])|[-_\s]+/) # Split at lowercase-to-uppercase transitions or explicit separators
+            .map(&:downcase) # Convert everything to lowercase for consistency
+
+    words.map.with_index { |word, index| index.zero? ? word : word.capitalize }.join
+  end
+end