mpw 4.1.1 → 4.2.0

data/lib/mpw/mpw.rb

@@ -25,7 +25,11 @@ require 'mpw/item'
 
 module MPW
   class MPW
-    # Constructor
+    # @param key [String] gpg key name
+    # @param wallet_file [String] path of the wallet file
+    # @param gpg_pass [String] password of the gpg key
+    # @param gpg_exe [String] path of the gpg executable
+    # @param pinmode [Boolean] enable the gpg pinmode
     def initialize(key, wallet_file, gpg_pass = nil, gpg_exe = nil, pinmode = false)
       @key         = key
       @gpg_pass    = gpg_pass
@@ -98,7 +102,7 @@ module MPW
       raise "#{I18n.t('error.mpw_file.read_data')}\n#{e}"
     end
 
-    # Encrypt a file
+    # Encrypt all data in tarball
     def write_data
       data     = {}
       tmp_file = "#{@wallet_file}.tmp"
@@ -154,7 +158,7 @@ module MPW
     end
 
     # Get a password
-    # args: id -> the item id
+    # @param id [String] the item id
     def get_password(id)
       password = decrypt(@passwords[id])
 
@@ -165,9 +169,9 @@ module MPW
       end
     end
 
-    # Set a password
-    # args: id -> the item id
-    #       password -> the new password
+    # Set a new password for an item
+    # @param id [String] the item id
+    # @param password [String] the new password
     def set_password(id, password)
       salt     = MPW.password(length: Random.rand(4..9))
       password = "$#{salt}::#{password}"
@@ -176,13 +180,13 @@ module MPW
     end
 
     # Return the list of all gpg keys
-    # rtrn: an array with the gpg keys name
+    # @return [Array] the gpg keys name
     def list_keys
       @keys.keys
     end
 
     # Add a public key
-    # args: key ->  new public key file or name
+    # @param key [String] new public key file or name
     def add_key(key)
       if File.exist?(key)
         data       = File.open(key).read
@@ -200,7 +204,7 @@ module MPW
     end
 
     # Delete a public key
-    # args: key ->  public key to delete
+    # @param key [String] public key to delete
     def delete_key(key)
       @keys.delete(key)
       @passwords.each_key { |id| set_password(id, get_password(id)) }
@@ -208,7 +212,7 @@ module MPW
     end
 
     # Add a new item
-    # @args: item -> Object MPW::Item
+    # @param item [Item]
     def add(item)
       raise I18n.t('error.bad_class') unless item.instance_of?(Item)
       raise I18n.t('error.empty')     if item.empty?
@@ -217,8 +221,8 @@ module MPW
     end
 
     # Search in some csv data
-    # @args: options -> a hash with paramaters
-    # @rtrn: a list with the resultat of the search
+    # @param options [Hash]
+    # @return [Array] a list with the resultat of the search
     def list(**options)
       result = []
 
@@ -240,9 +244,9 @@ module MPW
       result
     end
 
-    # Search in some csv data
-    # @args: id -> the id item
-    # @rtrn: a row with the result of the search
+    # Search an item with an id
+    # @param id [String]the id item
+    # @return [Item] an item or nil
     def search_by_id(id)
       @data.each do |item|
         return item if item.id == id
@@ -251,36 +255,35 @@ module MPW
       nil
     end
 
-    # Set an opt key
-    # args: id -> the item id
-    #       key -> the new key
+    # Set a new opt key
+    # @param id [String] the item id
+    # @param key [String] the new key
     def set_otp_key(id, key)
       @otp_keys[id] = encrypt(key.to_s) unless key.to_s.empty?
     end
 
     # Get an opt key
-    # args: id -> the item id
-    #       key -> the new key
+    # @param id [String] the item id
     def get_otp_key(id)
       @otp_keys.key?(id) ? decrypt(@otp_keys[id]) : nil
     end
 
     # Get an otp code
-    # @args: id -> the item id
-    # @rtrn: an otp code
+    # @param id [String] the item id
+    # @return [String] an otp code
     def get_otp_code(id)
       @otp_keys.key?(id) ? 0 : ROTP::TOTP.new(decrypt(@otp_keys[id])).now
     end
 
     # Get remaining time before expire otp code
-    # @rtrn: return time in seconde
+    # @return [Integer] time in seconde
     def get_otp_remaining_time
       (Time.now.utc.to_i / 30 + 1) * 30 - Time.now.utc.to_i
     end
 
     # Generate a random password
-    # @args: options -> :length, :special, :alpha, :numeric
-    # @rtrn: a random string
+    # @param options [Hash] :length, :special, :alpha, :numeric
+    # @return [String] a random string
     def self.password(**options)
       length =
         if !options.include?(:length) || options[:length].to_i <= 0
@@ -298,11 +301,9 @@ module MPW
       chars = [*('A'..'Z'), *('a'..'z'), *('0'..'9')] if chars.empty?
 
       result = ''
-      while length > 62
-        result << chars.sample(62).join
-        length -= 62
+      length.times do
+        result << chars.sample
       end
-      result << chars.sample(length).join
 
       result
     end
@@ -310,7 +311,8 @@ module MPW
     private
 
     # Decrypt a gpg file
-    # @args: data -> string to decrypt
+    # @param data [String] data to decrypt
+    # @return [String] data decrypted
     def decrypt(data)
       return nil if data.to_s.empty?
 
@@ -331,7 +333,8 @@ module MPW
     end
 
     # Encrypt a file
-    # args: data -> string to encrypt
+    # @param data [String] data to encrypt
+    # @return [String] data encrypted
     def encrypt(data)
       recipients = []
       crypto     = GPGME::Crypto.new(armor: true, always_trust: true)

data/test/files/fixtures-import.yml

@@ -0,0 +1,19 @@
+---
+1:
+  host: fric.com
+  user: 230403
+  group: Bank
+  password: 5XdiTQOubRDw9B0aJoMlcEyL
+  protocol: https
+  port:
+  otp_key: 330223432
+  comment: I love my bank
+2:
+  host: assurance.com
+  user: user_2132
+  group: Assurance
+  password: DMyK6B3v4bWO52VzU7aTHIem
+  protocol: https
+  port: 443 
+  otp_key: 
+  comment: 

data/test/files/fixtures.yml

@@ -1,28 +1,28 @@
-add_new:
-  group: 'test_group'
-  host: 'test_host'
-  protocol: 'test_protocol'
-  user: 'test_user'
-  password: 'test_password'
-  port: '42'
-  comment: 'test_comment'
+add:
+  group: 'Bank'
+  host: 'example.com'
+  protocol: 'https'
+  user: 'admin'
+  password: 'VmfnCN6pPIqgRIbc'
+  port: '8080'
+  comment: 'the website'
 
-add_existing:
+import:
   id: 'TEST-ID-XXXXX'
-  group: 'test_group_existing'
-  host: 'test_host_existing'
-  protocol: 'test_protocol_existing'
-  user: 'test_user_existing'
-  password: 'test_password_existing'
-  port: '44'
-  comment: 'test_comment_existing'
+  group: 'Cloud'
+  host: 'gogole.com'
+  protocol: 'https'
+  user: 'gg-2304'
+  password: 'TITl0kV9CDDa9sVK'
+  port: '8081'
+  comment: 'My little servers'
   created: 1386752948
 
 update:
-  group: 'test_group_update'
-  host: 'test_host_update'
-  protocol: 'test_protocol_update'
-  user: 'test_user_update'
-  password: 'test_password_update'
-  port: '43'
-  comment: 'test_comment_update'
+  group: 'Assurance'
+  host: 'example2.com'
+  protocol: 'ssh'
+  user: 'root'
+  password: 'kbSrbv4WlMaVxaZ7'
+  port: '2222'
+  comment: 'i love ssh'

data/test/init.rb

@@ -1,13 +1,17 @@
 #!/usr/bin/ruby
 
+require 'fileutils'
 require 'gpgme'
 
+FileUtils.rm_rf("#{Dir.home}/.config/mpw")
+FileUtils.rm_rf("#{Dir.home}/.gnupg")
+
 param = ''
 param << '<GnupgKeyParms format="internal">' + "\n"
 param << "Key-Type: RSA\n"
-param << "Key-Length: 2048\n"
+param << "Key-Length: 512\n"
 param << "Subkey-Type: ELG-E\n"
-param << "Subkey-Length: 2048\n"
+param << "Subkey-Length: 512\n"
 param << "Name-Real: test\n"
 param << "Name-Comment: test\n"
 param << "Name-Email: test2@example.com\n"

data/test/test_cli.rb

@@ -0,0 +1,265 @@
+#!/usr/bin/ruby
+
+require 'i18n'
+require 'test/unit'
+
+class TestConfig < Test::Unit::TestCase
+  def setup
+    if defined?(I18n.enforce_available_locales)
+      I18n.enforce_available_locales = true
+    end
+
+    I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
+    I18n.load_path = ["#{File.expand_path('../../i18n', __FILE__)}/en.yml"]
+    I18n.locale    = :en
+
+    @password = 'password'
+    @fixtures = YAML.load_file('./test/files/fixtures.yml')
+    @gpg_key  = 'test@example.com'
+  end
+
+  def test_00_init_config
+    output = %x(echo "#{@password}\n#{@password}" | mpw config --init #{@gpg_key})
+    assert_match(I18n.t('form.setup_config.valid'), output)
+    assert_match(I18n.t('form.setup_gpg_key.valid'), output)
+  end
+
+  def test_01_add_item
+    data = @fixtures['add']
+
+    output = %x(
+      echo #{@password} | mpw add \
+      --host #{data['host']} \
+      --port #{data['port']} \
+      --protocol #{data['protocol']} \
+      --user #{data['user']} \
+      --comment '#{data['comment']}' \
+      --group #{data['group']} \
+      --random
+    )
+    puts output
+    assert_match(I18n.t('form.add_item.valid'), output)
+
+    output = %x(echo #{@password} | mpw list)
+    puts output
+    assert_match(%r{#{data['protocol']}://.+#{data['host']}.+:#{data['port']}}, output)
+    assert_match(data['user'], output)
+    assert_match(data['comment'], output)
+    assert_match(data['group'], output)
+  end
+
+  def test_02_search
+    data = @fixtures['add']
+
+    output = %x(echo #{@password} | mpw list --group #{data['group']})
+    assert_match(%r{#{data['protocol']}://.+#{data['host']}.+:#{data['port']}}, output)
+
+    output = %x(echo #{@password} | mpw list --pattern #{data['host']})
+    assert_match(%r{#{data['protocol']}://.+#{data['host']}.+:#{data['port']}}, output)
+
+    output = %x(echo #{@password} | mpw list --pattern #{data['comment']})
+    assert_match(%r{#{data['protocol']}://.+#{data['host']}.+:#{data['port']}}, output)
+
+    output = %x(echo #{@password} | mpw list --group R1Pmfbp626TFpjlr)
+    assert_match(I18n.t('display.nothing'), output)
+
+    output = %x(echo #{@password} | mpw list --pattern h1IfnKqamaGM9oEX)
+    assert_match(I18n.t('display.nothing'), output)
+  end
+
+  def test_03_update_item
+    data = @fixtures['update']
+
+    output = %x(
+      echo #{@password} | mpw update \
+      -p #{@fixtures['add']['host']} \
+      --host #{data['host']} \
+      --port #{data['port']} \
+      --protocol #{data['protocol']} \
+      --user #{data['user']} \
+      --comment '#{data['comment']}' \
+      --new-group #{data['group']}
+    )
+    puts output
+    assert_match(I18n.t('form.update_item.valid'), output)
+
+    output = %x(echo #{@password} | mpw list)
+    puts output
+    assert_match(%r{#{data['protocol']}://.+#{data['host']}.+:#{data['port']}}, output)
+    assert_match(data['user'], output)
+    assert_match(data['comment'], output)
+    assert_match(data['group'], output)
+  end
+
+  def test_04_delete_item
+    output = %x(echo "#{@password}\ny" | mpw delete -p #{@fixtures['update']['host']})
+    puts output
+    assert_match(I18n.t('form.delete_item.valid'), output)
+
+    output = %x(echo #{@password} | mpw list)
+    puts output
+    assert_match(I18n.t('display.nothing'), output)
+  end
+
+  def test_05_import_export
+    file_import = './test/files/fixtures-import.yml'
+    file_export = '/tmp/test-mpw.yml'
+
+    output = %x(echo #{@password} | mpw import --file #{file_import})
+    assert_match(I18n.t('form.import.valid', file: file_import), output)
+
+    output = %x(echo #{@password} | mpw export --file #{file_export})
+    assert_match(I18n.t('form.export.valid', file: file_export), output)
+    assert(File.exist?(file_export))
+    assert_equal(YAML.load_file(file_export).length, 2)
+
+    YAML.load_file(file_import).each_value do |import|
+      error = true
+
+      YAML.load_file(file_export).each_value do |export|
+        next if import['host'] != export['host']
+
+        %w[user group password protocol port otp_key comment].each do |key|
+          assert_equal(import[key].to_s, export[key].to_s)
+        end
+
+        error = false
+      end
+      assert(!error)
+    end
+  end
+
+  def test_06_copy
+    data = YAML.load_file('./test/files/fixtures-import.yml')[1]
+
+    output = %x(
+      echo "#{@password}\np\nq" | mpw copy \
+      --disable-clipboard \
+      -p #{data['host']}
+    )
+    puts output
+    assert_match(data['password'], output)
+  end
+
+  def test_07_setup_wallet
+    path    = '/tmp/'
+    gpg_key = 'test2@example.com'
+
+    output = %x(echo #{@password} | mpw wallet --add-gpg-key #{gpg_key})
+    puts output
+    assert_match(I18n.t('form.add_key.valid'), output)
+
+    output = %x(echo #{@password} | mpw wallet --list-keys)
+    puts output
+    assert_match("| #{@gpg_key}", output)
+    assert_match("| #{gpg_key}", output)
+
+    output = %x(echo #{@password} | mpw wallet --delete-gpg-key #{gpg_key})
+    puts output
+    assert_match(I18n.t('form.delete_key.valid'), output)
+
+    output = %x(echo #{@password} | mpw wallet --list-keys)
+    puts output
+    assert_match("| #{@gpg_key}", output)
+    assert_no_match(/\| #{gpg_key}/, output)
+
+    output = %x(mpw wallet)
+    puts output
+    assert_match('| default', output)
+
+    output = %x(mpw wallet --path #{path})
+    puts output
+    assert_match(I18n.t('form.set_wallet_path.valid'), output)
+
+    output = %x(mpw config)
+    puts output
+    assert_match(%r{path_wallet_default.+\| #{path}/default.mpw}, output)
+    assert(File.exist?("#{path}/default.mpw"))
+
+    output = %x(mpw wallet --default-path)
+    puts output
+    assert_match(I18n.t('form.set_wallet_path.valid'), output)
+
+    output = %x(mpw config)
+    puts output
+    assert_no_match(/path_wallet_default/, output)
+  end
+
+  def test_08_setup_config
+    gpg_key    = 'user@example2.com'
+    gpg_exe    = '/usr/bin/gpg2'
+    wallet_dir = '/tmp/mpw'
+    length     = 24
+    wallet     = 'work'
+
+    output = %x(
+      mpw config \
+      --gpg-exe #{gpg_exe} \
+      --enable-pinmode \
+      --disable-alpha \
+      --disable-special-chars \
+      --disable-numeric \
+      --length #{length} \
+      --wallet-dir #{wallet_dir} \
+      --default-wallet #{wallet}
+    )
+    puts output
+    assert_match(I18n.t('form.set_config.valid'), output)
+
+    output = %x(mpw config)
+    puts output
+    assert_match(/gpg_key.+\| #{@gpg_key}/, output)
+    assert_match(/gpg_exe.+\| #{gpg_exe}/, output)
+    assert_match(/pinmode.+\| true/, output)
+    assert_match(/default_wallet.+\| #{wallet}/, output)
+    assert_match(/wallet_dir.+\| #{wallet_dir}/, output)
+    assert_match(/password_length.+\| #{length}/, output)
+    %w[numeric alpha special].each do |k|
+      assert_match(/password_#{k}.+\| false/, output)
+    end
+
+    output = %x(
+      mpw config \
+      --key #{gpg_key} \
+      --alpha \
+      --special-chars \
+      --numeric \
+      --disable-pinmode
+    )
+    puts output
+    assert_match(I18n.t('form.set_config.valid'), output)
+
+    output = %x(mpw config)
+    puts output
+    assert_match(/gpg_key.+\| #{gpg_key}/, output)
+    assert_match(/pinmode.+\| false/, output)
+    %w[numeric alpha special].each do |k|
+      assert_match(/password_#{k}.+\| true/, output)
+    end
+  end
+
+  def test_09_generate_password
+    length = 24
+
+    output = %x(
+      mpw genpwd \
+      --length #{length} \
+      --alpha
+    )
+    assert_match(/[a-zA-Z]{#{length}}/, output)
+
+    output = %x(
+      mpw genpwd \
+      --length #{length} \
+      --numeric
+    )
+    assert_match(/[0-9]{#{length}}/, output)
+
+    output = %x(
+      mpw genpwd \
+      --length #{length} \
+      --special-chars
+    )
+    assert_no_match(/[a-zA-Z0-9]/, output)
+  end
+end