secure-keys 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e1c55d0d0f427de2248176c7b637d099d707c49802d6e3ef2b726e0d3e2383a8
+  data.tar.gz: 6cbc1fcdc0a67dce1101ef372849d11f19e1ce07bd48ac52d9c3c34cf2188fed
+SHA512:
+  metadata.gz: 2a8e5c02474072f96dd7da0b61db861c313d8575e2bca0f42c57576f3081b58b7095fb47e17db01eff9ea5b756fac0be1e7d33351e5e4a143110640850fc6e69
+  data.tar.gz: f10ab748b3c5a74d4ef3b562ae555f5f6e1e93064fe25dc8a23fcfd185ab51baa08e148169a216d5694007ed8ddc0a760037d0b8c81b1233a4c9083a37ab515a

data/README.md

@@ -0,0 +1,193 @@
+<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/iOS-^13.0-blue" alt="iOS version 13.0">
+
+  <img src="https://img.shields.io/badge/Ruby-^3.3.6-red" alt="Ruby version 3.3.6">
+
+</div>
+
+# Secure Key Generator for iOS projects
+
+Utility to generate a `xcframework` for handling secure keys in iOS projects.
+
+### Prerequisites
+
+- Ruby 3.3.6 or higher
+- iOS 13.0 or higher
+
+### Installation
+
+Install gems using bundler
+
+```bash
+bundle install
+```
+
+If you don't have bundler installed, you can install it using:
+
+```bash
+gem install bundler
+```
+
+## Usage
+
+As first step, you need to determine the keys that you want to use in your iOS project. You can define the keys from Keychain or env variables.
+
+The source is determined by the current platform **local or CI / cloud** using the `CI` environment variable.
+
+If the `CI` environment variable is set to `true`, the keys are read from the environment variables. Otherwise, the keys are read from the Keychain.
+
+You can configure your keys like this:
+
+### From Keychain
+
+1. You need to define the `secure-keys` record in the Keychain with the key name and the key value.
+
+The value for this key should be all the key names separated by a comma.
+
+```bash
+security add-generic-password -a "secure-keys" -s "secure-keys" -w "githubToken,apiKey"
+```
+
+If you want to use another keychain identifier, you can define an env variable named `SECURE_KEYS_IDENTIFIER` to set the keychain identifier.
+
+```bash
+export SECURE_KEYS_IDENTIFIER="your-keychain-identifier"
+
+security add-generic-password -a "$SECURE_KEYS_IDENTIFIER" -s "$SECURE_KEYS_IDENTIFIER" -w "githubToken,apiKey"
+```
+
+2. You can add new keys using the `security` command.
+
+```bash
+security add-generic-password -a "secure-keys" -s "apiKey" -w "your-api-key"
+```
+
+Using custom keychain identifier:
+
+```bash
+security add-generic-password -a "$SECURE_KEYS_IDENTIFIER" -s "apiKey" -w "your-api-key"
+```
+
+### Environment variables
+
+1. You can define the keys in the `.env` file or export the keys as environment variables.
+
+```bash
+export SECURE_KEYS_IDENTIFIER="github-token,api_key,firebaseToken"
+
+export GITHUB_TOKEN="your-github-token"
+export API_KEY="your-api-key"
+export FIREBASETOKEN="your-firebase-token"
+```
+
+> The key names are formatted in uppercase and replace the `-` with `_`.
+
+> [!IMPORTANT]
+> If you want to use another demiliter, you can define an env variable named `SECURE_KEYS_DELIMITER` to set the delimiter.
+
+```bash
+export SECURE_KEYS_DELIMITER="|"
+
+export SECURE_KEYS_IDENTIFIER="github-token|api_key|firebaseToken"
+```
+
+### Ruby script
+
+To generate the `Keys.xcframework` use the `keys.rb` script with:
+
+```bash
+bundle exec ruby ./bin/keys.rb
+```
+
+### iOS project
+
+Within the iOS project, you can use the `Keys` target dependency like:
+
+```swift
+import Keys
+
+// Using key directly in the code
+let apiKey = Keys.apiKey.decryptedValue
+
+// Using key from `Key` enum
+let someKey: String = key(for: .someKey)
+
+// Alternative way to use key from `Key` enum
+let someKey: String = key(.someKey)
+
+// Using raw value from `Key` enum
+let apiKey: Keys = "apiKey".secretKey
+
+// Using raw value from `Key` enum with decrypted value
+let apiKey: String = "apiKey".secretKey.decryptedValue
+
+// Using `key` method to get the key
+let apiKey: String = .key(for: .apiKey)
+```
+
+## How to install the `Keys.xcframework` in the iOS project
+
+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)
+
+2. Click on the `Add Other...` button and click on the `Add Files...` option.
+
+![Add Files](/docs/assets/add-xcframework-to-ios-project/second-step.png)
+
+3. Navigate to the `keys` directory and select the `Keys.xcframework` folder.
+
+![Select Keys.xcframework](/docs/assets/add-xcframework-to-ios-project/third-step.png)
+
+> Now the `Keys.xcframework` is added to the iOS project.
+
+![Select Keys.xcframework](/docs/assets/add-xcframework-to-ios-project/third-step-result.png)
+
+4. Click on the `Build settings` tab and search for the `Search Paths` section.
+
+![Search Paths](/docs/assets/add-xcframework-to-ios-project/fourth-step.png)
+
+> Add the path to the `Keys.xcframework` in the `Framework Search Paths` section.
+
+```bash
+$(inherited)
+$(SRCROOT)/.keys
+```
+
+## How it works
+
+The process when the script is executed is:
+
+1. Create a `.keys` directory.
+2. Create a temporary `Swift Package` in the `.keys` directory.
+3. Copy the `Keys` source code to the temporary `Swift Package`.
+
+    ```swift
+    public enum Keys {
+
+        // MARK: - Cases
+
+        case apiKey
+        case someKey
+        case unknown
+
+        // MARK: - Properties
+
+        /// The decrypted value of the key
+        public var decryptedValue: String {
+            switch self {
+                case .apiKey: [1, 2, 4].decrypt(key: [248, 53, 26], iv: [148, 55, 47], tag: [119, 81])
+                case .someKey: [1, 2, 4].decrypt(key: [248, 53, 26], iv: [148, 55, 47], tag: [119, 81])
+                case .unknown: fatalError("Unknown key \(rawValue)")
+            }
+        }
+    }
+    ```
+4. Generate the `Keys.xcframework` using the temporary `Swift Package`.
+5. Remove the temporary `Swift Package`.
+
+## License
+
+This project is licensed under the MIT [License](LICENSE).

data/bin/keys.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require_relative '../lib/keys'
+
+# Generate the keys
+Keys::Generator.new.setup

data/lib/core/environment/ci.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+module Keys
+  module Core
+    module Environment
+      class CI
+        # Fetches the value of the environment variable with the given key.
+        # @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:)]
+        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
+end

data/lib/core/environment/keychain.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require 'osx_keychain'
+
+module Keys
+  module Core
+    module Environment
+      class Keychain
+        private
+
+        attr_accessor :keychain
+
+        public
+
+        def initialize
+          self.keychain = OSXKeychain.new
+        end
+
+        # Fetches the value of the keychain access item with the given key.
+        # @param key [String] the key of the keychain access item to fetch
+        # @return [String] the value of the keychain access item
+        def fetch(key:)
+          keychain[key, Keys::Globals.key_access_identifier]
+        rescue StandardError
+          puts "❌ Error fetching the key: #{key} from Keychain."
+        end
+      end
+    end
+  end
+end

data/lib/core/globals/globals.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+module Keys
+  module Globals
+    module_function
+
+    # Source: https://github.com/fastlane/fastlane/blob/b626fb18597eee88de0e08beba77070e2fecc299/fastlane_core/lib/fastlane_core/helper.rb#L73
+    # Check if the current build is running on a CI
+    # @return [Bool] true if the current build is running on a CI
+    def ci?
+      return true if circle_ci?
+
+      # 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')
+      end
+    end
+
+    # Check if the current build is running on CircleCI
+    # @return [Bool] true if the current build is running on CircleCI
+    def circle_ci?
+      ENV.key?('CIRCLECI')
+    end
+
+    # Returns the supported iOS platforms
+    # @return [Array] supported iOS platforms
+    def ios_platforms
+      [
+        {
+          name: 'iOS Simulator',
+          path: 'iphonesimulator'
+        },
+        {
+          name: 'iOS',
+          path: 'iphoneos'
+        }
+      ]
+    end
+
+    # Returns the identifier to get all the key names
+    # @return [String] key access identifier
+    def key_access_identifier
+      ENV['SECURE_KEYS_IDENTIFIER'] || default_key_access_identifier
+    end
+
+    # Returns the default key access identifier
+    # @return [String] default key access identifier
+    def default_key_access_identifier
+      'secure-keys'
+    end
+
+    # Returns the keys delimiter
+    # @return [String] keys delimiter
+    def key_delimiter
+      ENV['SECURE_KEYS_DELIMITER'] || default_key_delimiter
+    end
+
+    # Returns the default keys delimiter
+    # @return [String] default keys delimiter
+    def default_key_delimiter
+      ','
+    end
+  end
+end

data/lib/core/utils/openssl/cipher.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'openssl'
+require 'base64'
+require 'securerandom'
+
+module Keys
+  module OpenSSL
+    class Cipher
+      private
+
+      attr_accessor :secure_key, :cipher
+
+      public
+
+      # Initialize the cipher with a random generated key
+      # and the aes-256-gcm algorithm
+      # @param bytes [Integer] the number of bytes to generate the key
+      def initialize(bytes: 32)
+        self.secure_key = SecureRandom.random_bytes(bytes)
+        self.cipher = ::OpenSSL::Cipher.new('aes-256-gcm').encrypt
+
+        # Configure the cipher key using the random generated key
+        cipher.key = secure_key
+      end
+
+      # Encrypt a value using the cipher
+      # @param value [String] the value to encrypt
+      # @return [Hash] the encrypted value, the iv and the tag
+      def encrypt(value:)
+        iv = cipher.random_iv
+        encrypted_value = cipher.update(value) + cipher.final
+        tag = cipher.auth_tag
+
+        { iv: iv.bytes, value: encrypted_value.bytes, tag: tag.bytes }
+      end
+
+      # Fetch the bytes of the secure key
+      # @return [Array] the bytes of the secure key
+      def secure_key_bytes
+        secure_key.bytes
+      end
+    end
+  end
+end

data/lib/core/utils/swift/package.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require_relative './swift'
+
+module Keys
+  module Swift
+    class Package
+      # Generate the Swift Package using the configured path
+      def generate
+        command = <<~BASH
+          rm -rf #{SWIFT_PACKAGE_DIRECTORY} &&
+          mkdir -p #{SWIFT_PACKAGE_DIRECTORY} &&
+          cd #{SWIFT_PACKAGE_DIRECTORY} &&
+          swift package init --name #{SWIFT_PACKAGE_NAME} --type library
+        BASH
+
+        system(command)
+      end
+    end
+  end
+end

data/lib/core/utils/swift/swift.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+module Keys
+  module Swift
+    # Constants
+
+    # The name of the directory that contains the keys
+    KEYS_DIRECTORY = '.keys'.freeze
+
+    # The name of the directory that contains the generated build
+    BUILD_DIRECTORY = 'Build'.freeze
+
+    # The name of the Swift Package
+    SWIFT_PACKAGE_NAME = 'Keys'.freeze
+
+    # The name of the directory that contains the generated Swift package
+    SWIFT_PACKAGE_DIRECTORY = "#{KEYS_DIRECTORY}/Package".freeze
+
+    # The name of the directory that contains the generated xcframework
+    XCFRAMEWORK_DIRECTORY = "#{SWIFT_PACKAGE_NAME}.xcframework".freeze
+  end
+end

data/lib/core/utils/swift/writer.rb

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+# rubocop:disable Layout/HeredocIndentation
+
+require_relative './swift'
+
+module Keys
+  module Swift
+    class Writer
+      private
+
+      attr_accessor :mapped_keys, :secure_key_bytes, :key_file, :key_directory
+
+      public
+
+      # Initialize the writer with the mapped keys and the secure key bytes
+      # @param mapped_keys [Array<Hash>] The mapped keys
+      # @param secure_key_bytes [Array<UInt8>] The secure key bytes
+      def initialize(mapped_keys:, secure_key_bytes:)
+        self.mapped_keys = mapped_keys
+        self.secure_key_bytes = secure_key_bytes
+        self.key_file = "#{SWIFT_PACKAGE_NAME}.swift"
+        self.key_directory = "#{SWIFT_PACKAGE_DIRECTORY}/Sources/#{SWIFT_PACKAGE_NAME}"
+      end
+
+      # Write the keys to the file
+      def write
+        # Write the file
+        File.open("#{key_directory}/#{key_file}", 'w') do |file|
+          file.write(key_swift_file_template(content: formatted_keys))
+        end
+      end
+
+      private
+
+      # Generate the formatted keys content using Swift code format
+      # @return [String] The formatted keys content
+      def formatted_keys
+        <<~SWIFT
+        #{mapped_keys.map { |key| case_key_declaration_template(name: key[:name]) }.join("\t")}
+            case unknown
+
+            // MARK: - Properties
+
+            /// The decrypted value of the key
+            public var decryptedValue: String {
+                switch self {
+                    #{mapped_keys.map { |key| switch_case_key_declaration_template(name: key[:name], value: key[:value], iv: key[:iv], tag: key[:tag]) }.join("\t\t\t")}
+                    case .unknown: fatalError("Unknown key \\(rawValue)")
+                }
+            }
+        SWIFT
+      end
+
+      # Generate the Swift file template
+      # @param content [String] The content of the file
+      # @return [String] The Swift file template
+      def key_swift_file_template(content:)
+        <<~SWIFT
+        // swiftlint:disable all
+
+        import Foundation
+        import CryptoKit
+
+        // MARK: - Global methods
+
+        /// Fetch the decrypted value of the key
+        ///
+        /// - Parameter:
+        ///    - key: The key to fetch the decrypted value for
+        ///
+        /// - Returns: The decrypted value of the key
+        @available(iOS 13.0, *)
+        public func key(for key: Keys) -> String { key.decryptedValue }
+
+        /// Fetch the decrypted value of the key
+        ///
+        /// - Parameter:
+        ///    - key: The key to fetch the decrypted value for
+        ///
+        /// - Returns: The decrypted value of the key
+        @available(iOS 13.0, *)
+        public func key(_ key: Keys) -> String { key.decryptedValue }
+
+        // MARK: - Keys enum
+
+        /// Keys is a class that contains all the keys that are used in the application.
+        @available(iOS 13.0, *)
+        public enum Keys: String {
+
+            // MARK: - Cases
+
+            #{content}
+        }
+
+        // MARK: - Decrypt keys from array extension
+
+        @available(iOS 13.0, *)
+        extension Array where Element == UInt8 {
+
+            // MARK: - Methods
+
+            func decrypt(key: [UInt8], iv: [UInt8], tag: [UInt8]) -> String {
+                guard let sealedBox = try? AES.GCM.SealedBox(nonce: AES.GCM.Nonce(data: Data(iv)),
+                                                             ciphertext: Data(self),
+                                                             tag: Data(tag)),
+                      let decryptedData = try? AES.GCM.open(sealedBox, using: SymmetricKey(data: Data(key))),
+                      let decryptedKey = String(data: decryptedData, encoding: .utf8) else {
+                    fatalError("Failed to decrypt the key")
+                }
+                return decryptedKey
+            }
+        }
+
+        // MARK: - String extension for keys
+
+        @available(iOS 13.0, *)
+        extension String {
+
+            // MARK: - Methods
+
+            /// Fetch the key from the keys enum
+            public var secretKey: Keys { Keys(rawValue: self) ?? .unknown }
+
+            /// Fetch the decrypted value of the key
+            ///
+            /// - Parameters:
+            ///    - key: The key to fetch the decrypted value for
+            ///
+            /// - Returns: The decrypted value of the key
+            public static func key(for key: Keys) -> String { key.decryptedValue }
+        }
+
+        // swiftlint:enable all
+        SWIFT
+      end
+
+      # Generate the case key declaration template
+      # @param name [String] The name of the key
+      def case_key_declaration_template(name:)
+        <<~SWIFT
+        case #{name}
+        SWIFT
+      end
+
+      # Generate the switch case key declaration template
+      # @param name [String] The name of the key
+      def switch_case_key_declaration_template(name:, value:, iv:, tag:) # rubocop:disable Naming/MethodParameterName
+        <<~SWIFT
+        case .#{name}: #{value}.decrypt(key: #{secure_key_bytes}, iv: #{iv}, tag: #{tag})
+        SWIFT
+      end
+    end
+  end
+end
+
+# rubocop:enable Layout/HeredocIndentation

data/lib/core/utils/swift/xcframework.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+require_relative './swift'
+require_relative '../../globals/globals'
+
+module Keys
+  module Swift
+    class XCFramework
+      # Generate the XCFramework from the Swift package
+      def generate
+        # TODO: Add support for multiple platforms
+        # Currently this is failling with the following error:
+        # "library with the identifier 'ios-arm64' already exists."
+        %w[Release].each do |configuration|
+          Keys::Globals.ios_platforms.each do |platform|
+            generate_key_modules(configuration:, platform:)
+            generate_key_libraries(configuration:, platform: platform[:path])
+          end
+        end
+        generate_key_xcframework
+      end
+
+      private
+
+      # Generate the Swift package modules
+      # @param configuration [String] The configuration to build
+      # @param platform [Hash] The platform to build
+      def generate_key_modules(configuration:, platform:)
+        command = <<~BASH
+          cd #{SWIFT_PACKAGE_DIRECTORY} &&
+          xcodebuild -scheme #{SWIFT_PACKAGE_NAME} \
+            -sdk #{platform[:path]} \
+            -destination generic/platform="#{platform[:name]}" \
+            -configuration #{configuration} \
+            ARCHS="arm64" BUILD_DIR="../#{BUILD_DIRECTORY}"
+        BASH
+
+        system(command)
+      end
+
+      # Generate the Swift package libraries
+      # @param configuration [String] The configuration to build
+      # @param platform [String] The platform to build
+      def generate_key_libraries(configuration:, platform:)
+        command = <<~BASH
+          cd #{KEYS_DIRECTORY} &&
+          ar -crs #{BUILD_DIRECTORY}/#{configuration}-#{platform}/libKeys.a \
+            #{BUILD_DIRECTORY}/#{configuration}-#{platform}/Keys.o
+        BASH
+
+        system(command)
+      end
+
+      # Generate the XCFramework from the Swift package libraries
+      def generate_key_xcframework
+        command = <<~BASH
+          cd #{KEYS_DIRECTORY} &&
+          xcodebuild -create-xcframework \
+            #{xcframework_library_command} \
+            -allow-internal-distribution \
+            -output #{XCFRAMEWORK_DIRECTORY}
+        BASH
+
+        system(command)
+      end
+
+      # Generate the XCFramework library command
+      # @return [String] The XCFramework library command
+      def xcframework_library_command
+        # TODO: Add support for multiple platforms
+        # Currently this is failling with the following error:
+        # "library with the identifier 'ios-arm64' already exists."
+        %w[Release].map do |configuration|
+          Keys::Globals.ios_platforms.map do |platform|
+            "-library #{BUILD_DIRECTORY}/#{configuration}-#{platform[:path]}/libKeys.a"
+          end.join(' ')
+        end.join(' ')
+      end
+    end
+  end
+end

data/lib/keys.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require_relative './core/globals/globals'
+require_relative './core/environment/ci'
+require_relative './core/environment/keychain'
+require_relative './core/utils/swift/writer'
+require_relative './core/utils/swift/package'
+require_relative './core/utils/swift/swift'
+require_relative './core/utils/swift/xcframework'
+require_relative './core/utils/openssl/cipher'
+
+module Keys
+  class Generator
+    private
+
+    attr_accessor :cipher, :secrets_source, :secret_keys, :mapped_keys
+
+    public
+
+    def initialize
+      # If the secure keys identifier is not set, set it to 'secure-keys'
+      ENV['SECURE_KEYS_IDENTIFIER'] = 'secure-keys' unless ENV.key?('SECURE_KEYS_IDENTIFIER')
+
+      puts "🔔 You're using a custom delimiter '#{Keys::Globals.key_delimiter}'" unless Keys::Globals.key_delimiter.eql?(Keys::Globals.default_key_delimiter)
+      puts "🔔 You're using a custom key access identifier '#{Keys::Globals.key_access_identifier}'" unless Keys::Globals.key_access_identifier.eql?(Keys::Globals.default_key_access_identifier)
+
+      # Configure cipher
+      self.cipher = Keys::OpenSSL::Cipher.new
+
+      # Configure the secret source based on the environment
+      if Keys::Globals.ci?
+        self.secrets_source = Keys::Core::Environment::CI.new
+      else
+        self.secrets_source = Keys::Core::Environment::Keychain.new
+      end
+
+      # Define the keys that we want to map
+      self.secret_keys = secrets_source.fetch(key: Keys::Globals.key_access_identifier)
+                                       .to_s
+                                       .split(Keys::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:))
+        # Convert the first key chart to downcase
+        key[0] = key[0].downcase
+        { name: key, **encrypted_data }
+      end
+    end
+
+    def setup
+      pre_actions
+
+      package = Keys::Swift::Package.new
+      package.generate
+
+      writer = Keys::Swift::Writer.new(mapped_keys: mapped_keys,
+                                       secure_key_bytes: cipher.secure_key_bytes)
+      writer.write
+
+      xcframework = Keys::Swift::XCFramework.new
+      xcframework.generate
+
+      post_actions
+    end
+
+    private
+
+    def pre_actions
+      # Remove the keys directory
+      system("rm -rf #{Keys::Swift::KEYS_DIRECTORY}")
+    end
+
+    def post_actions
+      # Remove the keys directory
+      system("rm -rf #{Keys::Swift::SWIFT_PACKAGE_DIRECTORY}")
+
+      # Remove the build directory
+      system("rm -rf #{Keys::Swift::KEYS_DIRECTORY}/#{Keys::Swift::BUILD_DIRECTORY}")
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+module Keys
+  VERSION = '1.0.0'.freeze
+  SUMMARY = 'Keys is a simple tool for managing your secret keys'.freeze
+  DESCRIPTION = 'Keys is a simple tool to manage your secret keys in iOS your project'.freeze
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: secure-keys
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Derian Córdoba
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: digest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.10.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.10.1
+- !ruby/object:Gem::Dependency
+  name: osx_keychain
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.71.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.71.2
+description: Keys is a simple tool to manage your secret keys in iOS your project
+email:
+- derianricardo451@gmail.com
+executables:
+- keys.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- "./lib/core/environment/ci.rb"
+- "./lib/core/environment/keychain.rb"
+- "./lib/core/globals/globals.rb"
+- "./lib/core/utils/openssl/cipher.rb"
+- "./lib/core/utils/swift/package.rb"
+- "./lib/core/utils/swift/swift.rb"
+- "./lib/core/utils/swift/writer.rb"
+- "./lib/core/utils/swift/xcframework.rb"
+- "./lib/keys.rb"
+- "./lib/version.rb"
+- README.md
+- bin/keys.rb
+homepage: https://github.com/DerianCordobaPerez/secure-keys-generator
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Keys is a simple tool for managing your secret keys
+test_files: []