gtk2passwordapp 0.0.8 → 1.0.0

data/README.txt

@@ -1,7 +1,50 @@
-Just run:
-	gtk2passwordapp
+Ruby-Gnome Password Manager
 
-For some documentation on usage, see
+A Ruby-Gnome password manager.
+Uses crypt-tea's Tiny Encryption Algorithm to encrypt the datafile.
+Features random password generator and clipboard use.
+
+
+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 accout, 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, press the "Visible" button.
+The "Current" button copies the current password to the primary clipboard.
+The "Previous" button copies the previous password to the primary clipboard.
+
+To delete an account, select the account in the entry/combo box, and
+the press the "Delete Account" button.
+
+Once one has edited the account, clicking the "Update" button finalizes the record.
+Note, however, that the change is not yet permanent and saved on disk.
+Once one is done with all updates, one then needs to press "Save".
+"Cancel" or closing the window without "Save" will ignore all of the sessions updates.
+
+The "Change Data File Password" button will allow one the change
+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 "Cancel".
+
+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 the 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
 
 	http://ruby-gnome-apps.blogspot.com/search/label/Passwords
 

data/bin/gtk2passwordapp

@@ -1,40 +1,29 @@
 #!/usr/bin/env ruby
-# $Date: 2009/02/27 23:51:40 $
-##########################################################
-require 'lib/global_options_variables'
-GlobalOptionsVariables.set('0.0.8',
-        <<EOT
-Usage: #{$0.sub(/^.*\//,'')} [options]
+require 'rubygems'
+gem 'gtk2applib', '~> 3.1.0'
+require 'gtk2applib/gtk2_app'
 
-Options:
-        -h, --help      print this help text and exit
-        -v, --version   print program version and exit
-        -t, --test      test
-        -T, --trace     trace
-EOT
-        )
-require 'lib/setup_user_space'
-UserSpace.setup
-UserSpace.copy('/README.txt')
-require USER_CONF_DIR+CONF_FILE
-##########################################################
-require 'lib/gtk2passwordapp'
+application = {
+	:name		=> 'Ruby-Gnome Password Manager',
+	:tooltip	=> 'Password Manager',
+	:FILE		=> __FILE__,
+	}
+Gtk2App.init(application)
+Gtk2App.icon.set_icon_name(Gtk::Stock::DIALOG_AUTHENTICATION)
 
-lock = USER_CONF_DIR+'/lock'
-if File.exist?(lock) then
-  $stderr.puts "process already running?"
-  # user should then notice it's already running, but
-  # let's remove the lock in case it's not and user
-  # tries again....
-  File.unlink(lock)
-else
-  begin
-    File.open(lock,'w'){|fh| fh.puts $$ }
-    gpa = Gtk2PasswordApp.new
-    gpa.status_icon
-  rescue Exception
-    puts_bang!
-  ensure
-    File.unlink(lock) if File.exist?(lock)
-  end
+require 'gtk2passwordapp/edit_box.rb'
+require 'gtk2passwordapp/passwords.rb'
+passwords = Gtk2PasswordApp::Passwords.new
+Gtk2PasswordApp.build_menu(passwords)
+
+about = {
+	:authors	=> ['carlosjhr64@gmail.com'],
+	:comments	=> 'Ruby-Gtk2 Passsword Manager',
+	:website	=> 'http://ruby-gnome-apps.blogspot.com/search/label/Passwords',
+	:website_label	=> 'Ruby-Gnome Password Manager',
+	:license	=> 'GPL',
+	:copyright	=> '2009-Dec-14',
+	}
+Gtk2App.main_window(about) do |window|
+  Gtk2PasswordApp.edit(window,passwords)
 end

data/gtk2passwordapp/appconfig.rb

@@ -0,0 +1,29 @@
+# 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 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 = UserSpace::DIRECTORY
+
+  ENTRY_WIDTH	= (Gtk2App::HILDON)? 600: 300
+  LABEL_WIDTH	= 75
+  GO_BUTTON_LENGTH = 50
+  SPIN_BUTTON_LENGTH = 60
+  PAD		= 2	# cell padding
+
+  MAX_PASSWORD_LENGTH = 20
+  DEFAULT_PASSWORD_LENGTH = 7
+  MIN_PASSWORD_LENGTH = 3
+
+  # Switches the roles of PRIMARY and CLIPBOARD when true
+  SWITCH_CLIPBOARDS = Gtk2App::HILDON
+
+  PASSWORD_EXPIRED = 60*60*24*30*3 # 3 months
+
+  URL_PATTERN	= Regexp.new('^https?:\/\/[^\s\']+$')
+
+  FONT[:normal] = FONT[:large] = Pango::FontDescription.new( 'Arial 18' )	if Gtk2App::HILDON
+  GUI[:window_size] = [100,100]
+  MENU[:close]  = '_Close'
+end

data/gtk2passwordapp/edit_box.rb

@@ -0,0 +1,328 @@
+module Gtk2PasswordApp
+   include Configuration
+   PRIMARY	= Gtk::Clipboard.get((SWITCH_CLIPBOARDS)? Gdk::Selection::CLIPBOARD: Gdk::Selection::PRIMARY)
+   CLIPBOARD	= Gtk::Clipboard.get((SWITCH_CLIPBOARDS)? Gdk::Selection::PRIMARY: Gdk::Selection::CLIPBOARD)
+
+   @@index = nil
+   def self.build_menu(passwords)
+     passwords.accounts.each {|account|
+       item = Gtk2App.dock_menu.append_menu_item(account){
+         @@index = passwords.accounts.index(account)
+         PRIMARY.text   = passwords.password_of(account)
+         CLIPBOARD.text = passwords.username_of(account)
+       }
+       item.child.modify_fg(Gtk::STATE_NORMAL, RED) if passwords.expired?(account)
+     }
+     Gtk2App.dock_menu.show_all
+   end
+   def self.rebuild_menu(passwords)
+     items = Gtk2App.dock_menu.children
+     3.times{ items.shift } # shift out Quit, Run, and Spacer
+     while item = items.shift do
+       Gtk2App.dock_menu.remove(item)
+       item.destroy
+     end
+     Gtk2PasswordApp.build_menu(passwords)
+   end
+
+   def self.get_salt(title='Short Password')
+     dialog = Gtk::Dialog.new(
+         title,
+         nil, nil,
+         [ Gtk::Stock::QUIT,  0 ],
+         [ Gtk::Stock::OK,  1 ])
+ 
+     label = Gtk::Label.new(title)
+     label.justify = Gtk::JUSTIFY_LEFT
+     label.wrap = true
+     label.modify_font(Configuration::FONT[:normal])
+     dialog.vbox.add(label)
+     entry = Gtk::Entry.new
+     entry.visibility = false
+     entry.modify_font(Configuration::FONT[:normal])
+     dialog.vbox.add(entry)
+     dialog.show_all
+ 
+     entry.signal_connect('activate'){
+       dialog.response(1)
+     }
+ 
+     ret = nil
+     dialog.run {|response|
+       ret = entry.text.strip if response == 1
+     }
+     dialog.destroy
+ 
+     return ret
+   end
+ 
+   DIALOGS = Gtk2App::Dialogs.new
+
+   EDITOR_LABELS = [
+ 	:account,
+  	:url,
+  	:note,
+  	:username,
+  	:password,
+ 	]
+ 
+ 
+   EDITOR_BUTTONS = [
+ 	[ :random, :alphanum, :num, :alpha, :caps, ],
+ 	[ :visibility, :current, :previous, :cancel, :save, :update, ],
+ 	[ :delete, :cpwd ],
+ 	]
+ 
+   TEXT = {
+ 	# Labels
+ 	:account	=> 'Account',
+ 	:note		=> 'Note',
+ 	:password	=> 'New',
+ 	# Buttons
+ 	:username	=> 'Username',
+ 	:current	=> 'Current',
+ 	:url		=> 'Url',
+ 	:note		=> 'Note',
+ 	:edit		=> 'Edit',
+ 	:update		=> 'Update',
+ 	:visibility	=> 'Visible',
+ 	:alphanum	=> 'Alpha-Numeric',
+ 	:num		=> 'Numeric',
+ 	:alpha		=> 'Letters',
+ 	:caps		=> 'All-Caps',
+ 	:random		=> 'Random',
+ 	:previous	=> 'Previous',
+ 	:quit		=> 'Quit',
+ 	:cancel		=> 'Cancel',
+ 	:save		=> 'Save',
+ 	:cpwd		=> 'Change Data File Password',
+ 	:delete		=> 'Delete Account',
+   }
+ 
+   def self.edit(window, passwords)
+     begin
+       dialog_options = {:window=>window}
+       updated = false	# only saves data if data updated
+
+       vbox = Gtk::VBox.new
+       window.add(vbox)
+ 
+       pwdlength = Gtk::SpinButton.new(MIN_PASSWORD_LENGTH, MAX_PASSWORD_LENGTH, 1)
+       pwdlength.value = DEFAULT_PASSWORD_LENGTH
+       pwdlength.width_request = SPIN_BUTTON_LENGTH
+       pwdlength.modify_font(FONT[:normal])
+       goto_url = Gtk::Button.new('Go')
+       goto_url.child.modify_font(FONT[:normal])
+       goto_url.width_request = GO_BUTTON_LENGTH
+ 
+       widget = {}
+       EDITOR_LABELS.each {|s|
+         hbox = Gtk::HBox.new
+         #label = Gtk::Label.new(TEXT[s]+':',hbox)
+         label = Gtk2App::Label.new(TEXT[s]+':',hbox) # Gtk2App's Label
+         #label.modify_font(FONT[:normal])
+         label.width_request = LABEL_WIDTH
+         label.justify = Gtk::JUSTIFY_RIGHT
+         #label.wrap = true
+         widget[s] = (s==:account)? Gtk::ComboBoxEntry.new : Gtk::Entry.new
+         widget[s].width_request = ENTRY_WIDTH -
+		((s == :password)? (SPIN_BUTTON_LENGTH+2*GUI[:padding]):
+		((s == :url)? (GO_BUTTON_LENGTH+2*GUI[:padding]): 0))
+         widget[s].modify_font(FONT[:normal])
+         #hbox.pack_start(label, false, false, GUI[:padding])
+         hbox.pack_start(widget[s], false, false, GUI[:padding])
+         vbox.pack_start(hbox, false, false, GUI[:padding])
+         hbox.pack_start(pwdlength, false, false, GUI[:padding]) if s == :password
+         hbox.pack_start(goto_url, false, false, GUI[:padding]) if s == :url
+       }
+
+       # The go button opens the url in a browser
+       goto_url.signal_connect('clicked'){
+         system("#{APP[:browser]} #{widget[:url].text} > /dev/null 2> /dev/null &")
+       }
+ 
+       EDITOR_BUTTONS.each{|row|
+         hbox = Gtk::HBox.new
+         row.each {|s|
+           widget[s] = Gtk::Button.new(TEXT[s])
+           widget[s].child.modify_font(FONT[:normal])
+           hbox.pack_start(widget[s], false, false, GUI[:padding])
+         }
+         vbox.pack_start(hbox, false, false, GUI[:padding])
+       }
+ 
+       # Account
+       passwords.accounts.each { |account|
+         widget[:account].append_text( account )
+       }
+       widget[:account].active = @@index	if @@index
+       account_changed = proc {
+         account = (widget[:account].active_text)? widget[:account].active_text.strip: ''
+         if account.length > 0 then
+           widget[:password].text	= ''
+           if passwords.include?(account) then
+             widget[:url].text		= passwords.url_of(account)
+             widget[:note].text		= passwords.note_of(account)
+             widget[:username].text	= passwords.username_of(account)
+           else
+             widget[:url].text		= ''
+             widget[:note].text		= ''
+             widget[:username].text	= ''
+           end
+           @@index = widget[:account].active
+         end
+       }
+       account_changed.call
+       widget[:account].signal_connect('changed'){
+         account_changed.call
+       }
+ 
+       # New Password
+       widget[:password].visibility = false
+ 
+       # Update
+       widget[:update].signal_connect('clicked'){
+         url = widget[:url].text.strip
+         if url.length == 0 || url =~ URL_PATTERN then
+           account = (widget[:account].active_text)? widget[:account].active_text.strip: ''
+           if account.length > 0 then
+             updated = true if !updated
+             if !passwords.include?(account) then
+               passwords.add(account) 
+               @@index = i = passwords.accounts.index(account)
+               widget[:account].insert_text(i,account)
+             end
+             passwords.url_of(account, url)
+             passwords.note_of(account, widget[:note].text.strip)
+             passwords.username_of(account, widget[:username].text.strip)
+             password = widget[:password].text.strip
+             if password.length > 0 then
+               passwords.password_of(account, password) if !passwords.verify?(account, password)
+               widget[:password].text = ''
+             end
+           end
+         else
+           DIALOGS.quick_message('Need url like http://www.site.com/page.html', dialog_options)
+         end
+       }
+   
+       # Random
+       widget[:random].signal_connect('clicked'){
+         suggestion = ''
+         pwdlength.value.to_i.times do
+           suggestion += (rand(94)+33).chr
+         end
+         widget[:password].text = suggestion
+       }
+       # Alpha-Numeric
+       widget[:alphanum].signal_connect('clicked'){
+         suggestion = ''
+         while suggestion.length < pwdlength.value.to_i do
+           chr = (rand(75)+48).chr
+           suggestion += chr if chr =~/\w/
+         end
+         widget[:password].text = suggestion
+       }
+       # Numeric
+       widget[:num].signal_connect('clicked'){
+         suggestion = ''
+         pwdlength.value.to_i.times do
+           chr = (rand(10)+48).chr
+           suggestion += chr
+         end
+         widget[:password].text = suggestion
+       }
+       # Letters
+       widget[:alpha].signal_connect('clicked'){
+         suggestion = ''
+         while suggestion.length < pwdlength.value.to_i do
+           chr = (rand(58)+65).chr
+           suggestion += chr if chr =~/[A-Z]/i
+         end
+         widget[:password].text = suggestion
+       }
+       # Caps
+       widget[:caps].signal_connect('clicked'){
+         suggestion = ''
+         pwdlength.value.to_i.times do
+           chr = (rand(26)+65).chr
+           suggestion += chr
+         end
+         widget[:password].text = suggestion
+       }
+ 
+       # Visibility
+       widget[:visibility].signal_connect('clicked'){
+         widget[:password].visibility = !widget[:password].visibility?
+       }
+ 
+       # Current
+       widget[:current].signal_connect('clicked'){
+         account = (widget[:account].active_text)? widget[:account].active_text.strip: ''
+         PRIMARY.text = passwords.password_of(account)
+         CLIPBOARD.text = passwords.username_of(account)
+       }
+ 
+       # Previous
+       widget[:previous].signal_connect('clicked'){
+         account = (widget[:account].active_text)? widget[:account].active_text.strip: ''
+         PRIMARY.text = passwords.previous_password_of(account)
+         CLIPBOARD.text = passwords.username_of(account)
+       }
+ 
+       # Change Password
+       widget[:cpwd].signal_connect('clicked'){
+         if pwd1 = Gtk2PasswordApp.get_salt('New Password') then
+           if pwd2 = Gtk2PasswordApp.get_salt('Verify') then
+             while !(pwd1==pwd2) do
+               pwd1 = Gtk2PasswordApp.get_salt('Try again!')
+               return if !pwd1
+               pwd2 = Gtk2PasswordApp.get_salt('Verify')
+               return if !pwd2
+             end
+             #@pwd = pwd1
+             passwords.save(pwd1)
+           end
+         end
+       }
+ 
+       # Save
+       widget[:save].signal_connect('clicked'){
+         if updated then
+           passwords.save
+           updated = false
+           Gtk2PasswordApp.rebuild_menu(passwords)
+         end
+         Gtk2App.close
+       }
+ 
+       # Delete
+       widget[:delete].signal_connect('clicked'){
+         account = (widget[:account].active_text)? widget[:account].active_text.strip: nil
+         if account then
+           i = passwords.accounts.index(account)
+           if i then
+             passwords.delete(account)
+             widget[:account].remove_text(i)
+             @@index = (widget[:account].active = (i > 0)? i - 1: 0)
+             updated = true
+             DIALOGS.quick_message("#{account} deleted.", dialog_options)
+           end
+         end
+       }
+
+       # Cancel
+       widget[:cancel].signal_connect('clicked'){ Gtk2App.close }
+       window.signal_connect('destroy'){
+         if updated then
+           passwords.load # revert
+           updated = false
+         end
+       }
+ 
+       window.show_all
+     rescue Exception
+       puts_bang!
+     end
+   end
+end

data/gtk2passwordapp/iocrypt.rb

@@ -0,0 +1,30 @@
+require 'yaml'
+require 'rubygems'
+begin
+  require 'crypt_tea'
+rescue Exception
+  # above is what works, but documentation shows this...
+  require 'crypt-tea'
+end
+
+module Gtk2PasswordApp
+class IOCrypt
+  LENGTH = 15
+
+  def initialize(passphrase)
+    @key = Crypt::XXTEA.new(passphrase[0..LENGTH])
+  end
+
+  def load(dumpfile)
+    data = nil
+    File.open(dumpfile,'r'){|fh| data = YAML.load( @key.decrypt( fh.read ) ) }
+    return data
+  end
+
+  def dump(dumpfile, data)
+    count = nil
+    File.open(dumpfile,'w') { |fh| count = fh.write( @key.encrypt( YAML.dump( data ) ) ) }
+    return count
+  end
+end
+end

data/gtk2passwordapp/passwords.rb

@@ -0,0 +1,93 @@
+require 'gtk2passwordapp/passwords_data.rb'
+module Gtk2PasswordApp
+class Passwords < PasswordsData
+
+  def _create_passphrase
+    passphrase = ''
+
+    IOCrypt::LENGTH.times do
+      passphrase += (rand(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 = UserSpace::DIRECTORY+'/passphrase.txt'
+    if mv then
+      File.rename(@pfile, @pfile+'.bak') if File.exist?(@pfile)
+      passphrase = _create_passphrase
+    else
+      if File.exist?(@pfile) then
+        File.open(@pfile,'r'){|fh| passphrase = fh.read }
+      else
+        passphrase = _create_passphrase(@pfile)
+      end
+    end
+
+    return passphrase
+  end
+
+  def has_datafile?
+    Find.find(UserSpace::DIRECTORY){|fn|
+      Find.prune if !(fn==UserSpace::DIRECTORY) &&  File.directory?(fn)
+      if fn =~/[0123456789abcdef]{32}\.dat$/ then
+        return true
+      end
+    }
+    return false
+  end
+
+  attr_reader :pfile
+  def initialize
+    @pwd = Gtk2PasswordApp.get_salt || exit
+    @pfile = nil
+    @pph = get_passphrase
+    super(@pwd+@pph)
+    # Password file exist?
+    if self.exist? # then
+      # Yes, load passwords file.
+      self.load 
+    else
+      # 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 = Gtk2PasswordApp.get_salt('Try again!') || exit
+          super(@pwd+@pph)
+        end
+        self.load 
+      else
+      # Else, must be a new install.
+        pwd = @pwd
+        @pwd = Gtk2PasswordApp.get_salt('Verify New Password') || exit
+        while !(pwd == @pwd) do
+          pwd = Gtk2PasswordApp.get_salt('Try again!') || exit
+          @pwd = Gtk2PasswordApp.get_salt('Verify New Password') || exit
+        end
+      end
+    end
+    # Off to the races...
+  end
+
+  def save(pwd=nil)
+    if pwd then
+      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)
+    else
+      super()
+    end
+  end
+
+end
+end

data/{lib → gtk2passwordapp}/passwords_data.rb

@@ -1,11 +1,11 @@
-# $Date: 2009/02/26 00:27:18 $
-require 'lib/iocrypt'
+require 'gtk2passwordapp/iocrypt'
 require 'digest/md5'
 
+module Gtk2PasswordApp
 class PasswordsData
   include Configuration
   attr_accessor :account
-  attr_reader :data
+  attr_reader :data, :dumpfile
 
   PASSWORD	= 0
   PREVIOUS	= 1
@@ -16,13 +16,8 @@ class PasswordsData
 
   def _reset(passphrase)
     raise "Need a good passphrase" if !passphrase || passphrase.length < 7
-    @passphrase = passphrase[0..55]
+    @passphrase = passphrase[0..IOCrypt::LENGTH]
     @dumpfile = PASSWORDS_DATA_DIR + '/' + Digest::MD5.hexdigest(@passphrase) + '.dat'
-    @online = (@dumpfile =~ /^http:\/\//)? true: false
-  end
-
-  def online?
-    @online
   end
 
   def initialize(passphrase)
@@ -31,19 +26,16 @@ class PasswordsData
   end
 
   def exist?
-    raise "n/a online" if @online
     File.exist?(@dumpfile)
   end
 
   def load(passphrase = nil)
     _reset(passphrase) if passphrase 
-    raise "Wrong passphrase" if !@online && !exist?
     iocrypt = IOCrypt.new(@passphrase)
     @data = iocrypt.load(@dumpfile)
   end
 
   def save(passphrase = nil)
-    raise "n/a online" if @online
     # just in case, keep a backup
     File.rename(@dumpfile, @dumpfile+'.bak') if File.exist?(@dumpfile)
     _reset(passphrase) if passphrase 
@@ -53,7 +45,6 @@ class PasswordsData
   end
 
   def add(account)
-    raise "n/a online" if @online
     raise "Pre-existing" if @data[account]
     raise "Can't have nil account" if !account
     @data[account] = ['','','','','']
@@ -72,7 +63,6 @@ class PasswordsData
   end
 
   def delete(account)
-    raise "n/a online" if @online
     raise "#{account} not found" if !@data[account]
     @data.delete(account)
   end
@@ -117,3 +107,4 @@ class PasswordsData
     return @data[account][USERNAME]	|| ''
   end
 end
+end