gtk2passwordapp 1.8.0 → 2.0.0

data/README.txt

@@ -5,24 +5,18 @@ Uses crypt-tea's Tiny Encryption Algorithm to encrypt the datafile.
 Features random password generator and clipboard use.
 
 
-The main purpose of version 1.8 is to fix the "trust range" from "> 0" to "~> 1.0", so that version one can co-exist with version 2.
-
 To add an account, enter the new account name in the "Account:" entry/combo box.  For the account, write the associated url, a note about the account, and the username in the appropriate entry boxes.
 
-To set a new password, either enter the password in the "New:" entry box, or generate it by pressing "Random", "Alpha-Numeric", "Numeric", "Letters", or "All-Caps".  One can set the password length generated with the spin-box.  To make the password generated visible, un-check the check button.
+To set a new password, either enter the password in the "Password:" entry box, or generate it by pressing "Random", "Alpha-Numeric", "Numeric", "Letters", or "All-Caps".  One can set the password length generated with the spin-box.  To make the password generated visible, un-check the check button.
 
 Once one has edited the account, clicking the "Update Account" button finalizes the record.  Note, however, that the change is not yet permanent and saved on disk.  To delete an account, select the account in the entry/combo box, and the press the "Delete Account" button.  Once one is done with all updates, one then needs to press "Save To Disk".  Clicking the "Close" button or closing the window without "Save To Disk" will ignore all of the sessions updates.
 
 The "Clip Current Password" button copies the current password to the primary clipboard.  The "Clip Previous Password" button copies the previous (old) password to the primary clipboard.  The "Change Data File Password" button will allow one the change the master password.  Do not forget the master password!
 
-Right click most anywhere on the app's window for the main menu.  "Close" will dock the app and has the same effect as the "Close" button.
+Right click most anywhere on the app's window for the main menu.  "Close" will dock the application and has the same effect as the "Close" button.
 
 Left click on the docked icon to bring back the editor window.  Right click on the docked icon to select one of the accounts to load the password and username to the clipboard.  The password is copied to the primary clipboard and will paste on middle mouse button click.  Right click on an entry box to paste the username (via the clipboard's menu).
 
-Lastly, do not edit
-	~/.gtk2passwordapp-1/passphrase.txt
-It's used to "salt" the password... without it, one will not be able to decrypt the datafile.
-
 For full documentation and comments, see
 https://sites.google.com/site/gtk2applib/home/gtk2applib-applications/gtk2passwordapp
 

data/bin/{gtk2passwordapp → gtk2passwordapp2}

@@ -2,16 +2,13 @@
 require 'rubygems'
 gem 'gtk2applib', '~> 15.3'
 require 'gtk2applib'
-gem 'gtk2passwordapp', '~> 1.0'
 require 'gtk2passwordapp'
 
 if $options=~/-no-gui/ then
-  puts "Warning: password will be shown."
-  print "Salt:"
-  salt = $stdin.gets.strip
-  passwords = Gtk2Password::Passwords.new(salt)
-  puts "Warning: selected passwords will be shown."
-  print "Enter Account pattern:"
+  print Gtk2Password::Configuration::COMMAND_LINE_MSG1
+  pwd = $stdin.gets.strip
+  passwords = Gtk2Password::Passwords.new(Gtk2Password::Configuration::PASSWORDS_FILE, pwd)
+  print Gtk2Password::Configuration::COMMAND_LINE_MSG2
   pattern = Regexp.new( $stdin.gets.strip, Regexp::IGNORECASE )
   passwords.accounts.each do |account|
     if account =~ pattern then

data/lib/gtk2passwordapp/appconfig.rb

@@ -1,10 +1,8 @@
-# Note: you'll see in ~/.gtk2passwordapp-* a file called passphrase.txt.
-# Do not edit or delete passphrase, or you'll loose your passwords data.
-
 module Gtk2AppLib
-# Only one gtk2passwordapp will be allowed to run.
-# Will kill a duplicate proccess...
-Lock.lock_mode
+  # Only one gtk2passwordapp will be allowed to run.
+  # Will kill a duplicate proccess...
+  Lock.lock_mode
+
 module Configuration
 
   padding = Widgets::WIDGET[:Widgets][:pack_start].last
@@ -22,7 +20,7 @@ module Configuration
     spin = 75
     check = 25
     if Gtk2AppLib::Configuration::OSTYPE == 'Internet Tablet OS: maemo Linux based OS2008' then
-      # Icon works on N800, but not N800 (Maemo 5)
+      # Icon works on N800, but not N900 (Maemo 5)
       MENU[:close]		= '_Close'
     end
   else
@@ -82,12 +80,12 @@ module Gtk2Password
 module Configuration
   # Note that the passwords data file name is auto generated, but...
   # You can place your passwords data file in a directory other than ~/gtk2passwordapp-*
-  PASSWORDS_DATA_DIR = Gtk2AppLib::USERDIR
+  PASSWORDS_FILE = File.join( Gtk2AppLib::USERDIR, 'passwords.dat' )
   # Switches the roles of PRIMARY and CLIPBOARD when true
   SWITCH_CLIPBOARDS	= (Gtk2AppLib::HILDON || !Gtk2AppLib::Configuration::X)? true: false
   PASSWORD_EXPIRED	= 60*60*24*30*3 # 3 months
   URL_PATTERN		= Regexp.new('^https?:\/\/[^\s\']+$')
-  DEFAULT_PASSWORD_LENGTH = 7
+  DEFAULT_PASSWORD_LENGTH = 16
   EXPIRED_COLOR = Gtk2AppLib::Color[:Red]
 
   BAD_URL = ['Need url like http://www.site.com/page.html',{:TITLE => 'Error: Bad Url',:SCROLLED_WINDOW => false}]
@@ -113,22 +111,26 @@ module Configuration
 	['Datafile',	hbox,	[:Datafile_Button]],
 	['Clip',	hbox,	[:Current_Button,:Previous_Button]],
     ]
+
+  # These are the prompts for passwords
+  PASSWORD = 'Password' # for when for asking.
+  AGAIN = 'Again' # for when verifying new passwords.
+  RETRY = 'Retry' # for when you got your password wrong.
+
+  # These are the --no-gui dialogs...
+  COMMAND_LINE_MSG1 = "Warning: password will be shown.\nPassword:"
+  COMMAND_LINE_MSG2 = "Warning: selected passwords will be shown.\nEnter Account pattern:"
 end
 
-  def self.passwords_updated(dumpfile)
+  def self.passwords_updated
     ## After the password files are saved, you have the option here to backup or mirror the files elsewhere.
     ## Here's an example:
-    # system( "ssh user@192.168.1.123 mv .gtk2passwordapp-1/*.dat .gtk2passwordapp-1/bak/")
-    # system( "ssh user@192.168.1.123 cp .gtk2passwordapp-1/passphrase.txt .gtk2passwordapp-1/bak/passphrase.txt") # you might choose not too.
-    # fn = File.basename(dumpfile)
-    # if system( "scp #{dumpfile} user@192.168.1.123:.gtk2passwordapp-1/#{fn}")	then
-    # # again, you might choose not to distribute passphrase (reduces cracking to your short password)
-    # if system( "scp #{Configuration::PASSWORDS_DATA_DIR}/passphrase.txt user@192.168.1.123:.gtk2passwordapp-1/passphrase.txt") then
-    #   Gtk2AppLib::DIALOGS.quick_message("Passwords saved on 192.168.1.101 and 102")
-    #   return
-    # end
-    # end
-    # Gtk2AppLib::DIALOGS.quick_message("Warning: Could not create backup on 192.168.1.123")
+    #n = '123'
+    #if system( "scp ~/.gtk2passwordapp-2/passwords.dat user@192.168.1.#{n}:.gtk2passwordapp-2/passwords.dat")   then
+    #  Gtk2AppLib::DIALOGS.quick_message("Passwords saved on 192.168.1.#{n}",{:TITLE => 'Saved',:SCROLLED_WINDOW => false})
+    #  return
+    #end
+    #Gtk2AppLib::DIALOGS.quick_message("Warning: Could not create backup on 192.168.1.#{n}",{:TITLE => 'Warning',:SCROLLED_WINDOW => false})
     Gtk2AppLib::DIALOGS.quick_message("Passwords Data Saved.",{:TITLE => 'Saved',:SCROLLED_WINDOW => false})
   end
 end

data/lib/gtk2passwordapp/iocrypt.rb

@@ -11,10 +11,10 @@ end
 module Gtk2Password
 # Wrapper around Crypt::XXTEA
 class IOCrypt
-  LENGTH = 15
+  LENGTH = 16
 
   def initialize(passphrase)
-    @key = Crypt::XXTEA.new(passphrase[0..LENGTH])
+    @key = Crypt::XXTEA.new(passphrase[0..(LENGTH-1)])
   end
 
   def load(dumpfile)

data/lib/gtk2passwordapp/passwords.rb

@@ -1,104 +1,44 @@
 require 'gtk2passwordapp/passwords_data'
-require 'gtk2passwordapp/rnd'
 module Gtk2Password
 # Passwords subclasses PasswordsData :P
 class Passwords < PasswordsData
 
-  def _create_passphrase
-    passphrase = ''
+  # Configurable prompts
+  PROMPT = {
+	:password	=> 'Password',
+	:again		=> 'Again',
+	:retry		=> 'Retry',
+  }
 
-    IOCrypt::LENGTH.times do
-      passphrase += (Rnd::RND.random(94)+33).chr
-    end
-    File.open(@pfile,'w'){|fh| fh.write passphrase }
-    File.chmod(0600, @pfile)
-
-    return passphrase
-  end
-
-  def get_passphrase(mv=false)
-    passphrase = ''
-
-    @pfile = Gtk2AppLib::USERDIR+'/passphrase.txt'
-    exists = File.exist?(@pfile)
-    if mv then
-      File.rename(@pfile, @pfile+'.bak') if exists
-      passphrase = _create_passphrase
-    else
-      if exists then
-        File.open(@pfile,'r'){|fh| passphrase = fh.read }
-      else
-        passphrase = _create_passphrase
-      end
-    end
-
-    return passphrase
-  end
-
-  def has_datafile?
-    Find.find(Gtk2AppLib::USERDIR){|fn|
-      Find.prune if !(fn==Gtk2AppLib::USERDIR) &&  File.directory?(fn)
-      if fn =~/[0123456789abcdef]{32}\.dat$/ then
-        return true
-      end
-    }
-    return false
-  end
-
-  def self._get_salt(prompt)
-    (ret = Gtk2Password.get_salt(prompt,'Salt')) || exit
-    ret.strip
-  end
-
-  attr_reader :pfile
-  def initialize(pwd=nil)
-    @pwd = pwd || Passwords._get_salt('Short Password')
-    @pfile = nil
-    @pph = get_passphrase
-    super(@pwd+@pph)
-    # Password file exist?
-    if self.exist? # then
-      # Yes, load passwords file.
-      self.load 
-    else
-      raise "bad salt" if pwd
-      # No, check if there is a file....
-      if has_datafile? # then
-        # Yes, it's got a datafile. Ask for password again.
-        while !self.exist? do
-          @pwd = Passwords._get_salt('Try again!')
-          super(@pwd+@pph)
-        end
-        self.load 
-      else
-      # Else, must be a new install.
-        pwd = @pwd
-        @pwd = Passwords._get_salt('Verify New Password')
-        while !(pwd == @pwd) do
-          pwd = Passwords._get_salt('Try again!')
-          @pwd = Passwords._get_salt('Verify New Password')
+  def initialize(dump,pwd=nil)
+    if pwd.nil? then
+      pwd = yield(PROMPT[:password])
+      again = true
+      while again do
+        super(dump,pwd)
+        begin
+          # Password file exist?
+          if self.exist? # then
+            # Yes, load passwords file.
+            self.load 
+          else
+            verify = nil
+            while !(verify == pwd) do
+              verify = pwd
+              pwd = yield(PROMPT[:again])
+            end
+            super(dump,pwd)
+            self.save
+          end
+          again = false # good to go!
+        rescue StandardError
+          pwd = yield(PROMPT[:retry])
         end
-        super(@pwd+@pph)
-        self.save
       end
-    end
-    # Off to the races...
-  end
-
-  def save(pwd=nil)
-    if pwd.nil? then
-      super()
     else
-      pfbak = self.pfile + '.bak'
-      pph = get_passphrase(true) # new passphrase
-      dfbak = self.dumpfile + '.bak'
-      super(pwd+pph)
-      @pwd = pwd
-      @pph = pph
-      File.unlink(pfbak) if File.exist?(pfbak)
-      File.unlink(dfbak) if File.exist?(dfbak)
+      super(dump,pwd)
     end
-    return self.dumpfile
+    # Off to the races...
   end
 
 end

data/lib/gtk2passwordapp/passwords_data.rb

@@ -4,9 +4,6 @@ require 'digest/md5'
 module Gtk2Password
 # PasswordsData maitains passwords
 class PasswordsData
-  include Configuration
-  attr_accessor :account
-  attr_reader :data, :dumpfile
 
   PASSWORD	= 0
   PREVIOUS	= 1
@@ -15,14 +12,18 @@ class PasswordsData
   URL		= 4
   LAST_UPDATE	= 5
 
-  def _reset(passphrase)
-    raise "Need a good passphrase" if !passphrase || passphrase.length < 7
-    @passphrase = passphrase[0..IOCrypt::LENGTH]
-    @dumpfile = PASSWORDS_DATA_DIR + '/' + Digest::MD5.hexdigest(@passphrase) + '.dat'
+  def reset(password)
+    # MD5 digest length is 16 to match tiny encryption's block length
+    passphrase = Digest::MD5.digest( password )
+    @iocrypt =  IOCrypt.new(passphrase)
   end
 
-  def initialize(passphrase)
-    _reset(passphrase)
+  attr_reader :data
+  attr_accessor :expired, :dumpfile
+  def initialize(dumpfile,password)
+    reset(password) # sets @iocrypt
+    @dumpfile = dumpfile
+    @expired = 60*60*24*30*3 # 3 months
     @data = {}
   end
 
@@ -30,33 +31,36 @@ class PasswordsData
     File.exist?(@dumpfile)
   end
 
-  def load(passphrase = nil)
-    _reset(passphrase) if !passphrase.nil?
-    iocrypt = IOCrypt.new(@passphrase)
-    @data = iocrypt.load(@dumpfile)
+  # will raise an exception on failed decryption
+  def load
+    data = @iocrypt.load(@dumpfile)
+    raise "decryption error" unless data.class == Hash
+    @data = data
   end
 
-  def save(passphrase = nil)
+  def save
     # just in case, keep a backup
-    File.rename(@dumpfile, @dumpfile+'.bak') if File.exist?(@dumpfile)
-    _reset(passphrase) if !passphrase.nil?
-    iocrypt = IOCrypt.new(@passphrase)
-    iocrypt.dump(@dumpfile, @data)
+    @iocrypt.dump(@dumpfile, @data)
     File.chmod(0600, @dumpfile)
   end
 
+  def save!(password)
+    reset(password)
+    save
+  end
+
   def add(account)
-    raise "Pre-existing" if @data[account]
-    raise "Can't have nil account" if account.nil?
-    @data[account] = ['','','','','']
+    raise "pre-existing" unless @data[account].nil?
+    raise "can't have nil account" if account.nil?
+    @data[account] = [ '', '', '', '', '', 0 ]
   end
 
   def accounts
-    @data.keys.sort
+    @data.keys.sort{|a,b| a.upcase <=> b.upcase }
   end
 
   def include?(account)
-    return (@data[account])? true: false
+    return !@data[account].nil?
   end
 
   def verify?(account,password)
@@ -64,55 +68,65 @@ class PasswordsData
   end
 
   def delete(account)
-    raise "#{account} not found" if !@data[account]
+    raise "#{account} not found" if @data[account].nil?
     @data.delete(account)
   end
 
-  def url_of(account, url=nil)
+  def get_data_account(account)
     data_account = @data[account]
     raise "#{account} not found" if data_account.nil?
-    data_account[URL] = url if !url.nil?
-    return data_account[URL]	|| ''
+    return data_account
+  end
+
+  def self.url_of(data_account, url)
+    data_account[URL] = url unless url.nil?
+    return data_account[URL]
+  end
+
+  def url_of(account, url=nil)
+    PasswordsData.url_of( get_data_account(account), url )
   end
 
   def expired?(account)
-    data_account = @data[account]
-    raise "#{account} not found" if data_account.nil?
+    data_account = get_data_account(account)
     last_update = data_account[LAST_UPDATE]
-    return true if last_update.nil? || ((Time.now.to_i - last_update) > PASSWORD_EXPIRED)
-    return false
+    ((Time.now.to_i - last_update) > @expired)
+  end
+
+  def self.password_of(data_account,password)
+    data_account[PREVIOUS] = data_account[PASSWORD]
+    data_account[PASSWORD] = password
+    data_account[LAST_UPDATE] = Time.now.to_i
   end
 
   def password_of(account, password=nil)
-    data_account = @data[account]
-    raise "#{account} not found" if data_account.nil?
-    if !password.nil? then
-      data_account[PREVIOUS] = data_account[PASSWORD]
-      data_account[PASSWORD] = password
-      data_account[LAST_UPDATE] = Time.now.to_i
-    end
-    return data_account[PASSWORD]	|| ''
+    data_account = get_data_account(account)
+    PasswordsData.password_of(data_account,password) unless password.nil?
+    return data_account[PASSWORD]
   end
 
   # previous password
   def previous_password_of(account)
-    data_account = @data[account]
-    raise "#{account} not found" if data_account.nil?
-    return data_account[PREVIOUS]	|| ''
+    data_account = get_data_account(account)
+    return data_account[PREVIOUS]
+  end
+
+  def self.note_of(data_account,note)
+    data_account[NOTE] = note unless note.nil?
+    return data_account[NOTE]
   end
 
   def note_of(account, note=nil)
-    data_account = @data[account]
-    raise "#{account} not found" if data_account.nil?
-    data_account[NOTE] = note if !note.nil?
-    return data_account[NOTE]	|| ''
+    PasswordsData.note_of( get_data_account(account), note )
+  end
+
+  def self.username_of(data_account,usr)
+    data_account[USERNAME] = usr unless usr.nil?
+    return data_account[USERNAME]
   end
 
   def username_of(account, usr=nil)
-    data_account = @data[account]
-    raise "#{account} not found" if data_account.nil?
-    data_account[USERNAME] = usr if !usr.nil?
-    return data_account[USERNAME]	|| ''
+    PasswordsData.username_of( get_data_account(account), usr )
   end
 end
 end

data/lib/gtk2passwordapp/rnd.rb

@@ -12,47 +12,62 @@ module Gtk2Password
       REALRAND = false
     end
 
+    BUCKET_LENGTH = 100
+    NUMBERS = [75,10,58,26,94]
+    LCF = 2657850
+
+    attr_reader :bucket, :refilling
     def initialize
       @bucket = []
       @refilling = false
       self.refill	if REALRAND
     end
 
+    def refill_timeout
+      Timeout.timeout(60) do
+        generator = Random::RandomOrg.new
+        @bucket += generator.randnum(BUCKET_LENGTH, 0, LCF - 1)
+      end
+    end
+
     def refill
       return if @refilling
       @refilling = true
       Thread.new do
         begin
-          Timeout.timeout(60) do
-            generator1 = Random::RandomOrg.new
-            @bucket += generator1.randnum(200, 0, 2657849) # 2657850 % <75,10,58,26,94>
-          end
+          Thread.pass
+          refill_timeout
         rescue Exception
           $stderr.puts $!
-          $stderr.puts "Failed to fill the bucket"
         ensure
           @refilling = false
         end
       end
     end
 
-    def random(n)
-      if ![75,10,58,26,94].include?(n) then
+    def self.randomize(rnd,number)
+      ((rnd + rand(number)) % number)
+    end
+
+    def real_random(number)
+      refill if @bucket.length < BUCKET_LENGTH/2
+      if rnd = @bucket.shift then
+        return Rnd.randomize(rnd,number)
+      else
+        return rand(number)
+      end
+    end
+
+    def validate(number)
+      if !NUMBERS.include?(number) then
         $stderr.puts "Did not code for that number" 
         exit # seriously messed up! :))
       end
-      if REALRAND then
-        refill if @bucket.length < 100
-        if rnd = @bucket.shift then
-          rnd = ((rnd + rand(n)) % n)
-          return rnd
-        else
-          return rand(n)
-        end
-      else
-        return rand(n)
-      end
-      raise "Should not get here"
+    end
+
+    def random(number)
+      validate(number)
+      (REALRAND)? real_random(number) : rand(number)
     end
 
     RND = Rnd.new

data/lib/gtk2passwordapp.rb

@@ -4,18 +4,22 @@ require 'gtk2passwordapp/rnd'
 module Gtk2Password
 
   ABOUT		= {
-	'name'		=> 'Ruby-Gnome Password Manager',
+	'name'		=> 'Ruby-Gnome Password Manager II',
 	'authors'	=> ['carlosjhr64@gmail.com'],
 	'website'	=> 'https://sites.google.com/site/gtk2applib/home/gtk2applib-applications/gtk2passwordapp',
 	'website-label'	=> 'Ruby-Gnome Password Manager',
         'license'        => 'GPL',
-        'copyright'      => '2011-06-19 21:49:32',
+        'copyright'      => '2011-07-02 17:53:12',
   }
 
   PRIMARY	= Gtk::Clipboard.get((Configuration::SWITCH_CLIPBOARDS)? Gdk::Selection::CLIPBOARD: Gdk::Selection::PRIMARY)
   CLIPBOARD	= Gtk::Clipboard.get((Configuration::SWITCH_CLIPBOARDS)? Gdk::Selection::PRIMARY: Gdk::Selection::CLIPBOARD)
 
-  def self.get_salt(prompt,title=prompt)
+  Passwords::PROMPT[:password]	= Configuration::PASSWORD
+  Passwords::PROMPT[:again]	= Configuration::AGAIN
+  Passwords::PROMPT[:retry]	= Configuration::RETRY
+
+  def self.get_password(prompt,title=prompt)
     Gtk2AppLib::DIALOGS.entry( prompt, {:TITLE=>title, :Entry => [{:visibility= => false},'activate']} )
   end
 
@@ -31,7 +35,9 @@ module Gtk2Password
 
     def initialize(program)
       @program		= program
-      @passwords	= Gtk2Password::Passwords.new
+      @passwords	= Gtk2Password::Passwords.new(Configuration::PASSWORDS_FILE) do |prompt|
+        Gtk2Password.get_password(prompt)	|| exit
+      end
       @modified		= false
       self.build_menu
       program.window do |window|
@@ -60,8 +66,8 @@ module Gtk2Password
     end
 
     def _save
-      dumpfile = @passwords.save
-      Gtk2Password.passwords_updated(dumpfile)
+      @passwords.save
+      Gtk2Password.passwords_updated
       build_menu
     end
 
@@ -220,16 +226,16 @@ module Gtk2Password
         end
 
       when @gui[:datafile_button]
-        if pwd1 = Gtk2Password.get_salt('New Password') then
-          if pwd2 = Gtk2Password.get_salt('Verify') then
+        if pwd1 = Gtk2Password.get_password(Passwords::PROMPT[:password]) then
+          if pwd2 = Gtk2Password.get_password(Passwords::PROMPT[:again]) then
             while !(pwd1==pwd2) do
-              pwd1 = Gtk2Password.get_salt('Try again!')
+              pwd1 = Gtk2Password.get_password(Passwords::PROMPT[:retry])
               return if !pwd1
-              pwd2 = Gtk2Password.get_salt('Verify')
+              pwd2 = Gtk2Password.get_password(Passwords::PROMPT[:again])
               return if !pwd2
             end
-            dumpfile = @passwords.save(pwd1)
-            Gtk2Password.passwords_updated(dumpfile)
+            @passwords.save!(pwd1)
+            Gtk2Password.passwords_updated
           end
         end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gtk2passwordapp
 version: !ruby/object:Gem::Version 
-  hash: 55
+  hash: 15
   prerelease: 
   segments: 
-  - 1
-  - 8
+  - 2
   - 0
-  version: 1.8.0
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
 - carlosjhr64@gmail.com
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-03 00:00:00 Z
+date: 2011-07-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: crypt-tea
@@ -55,7 +55,7 @@ description: |
 
 email: carlosjhr64@gmail.com
 executables: 
-- gtk2passwordapp
+- gtk2passwordapp2
 extensions: []
 
 extra_rdoc_files: []
@@ -70,7 +70,7 @@ files:
 - ./pngs/logo.png
 - ./pngs/icon.png
 - README.txt
-- bin/gtk2passwordapp
+- bin/gtk2passwordapp2
 homepage: https://sites.google.com/site/gtk2applib/home/gtk2applib-applications/gtk2passwordapp
 licenses: []