gtk2passwordapp 0.0.1

data/README.txt

@@ -0,0 +1,8 @@
+Just run:
+	gtk2passwordapp
+
+For some documentation on usage, see
+
+	http://ruby-gnome-apps.blogspot.com/search/label/Passwords
+
+-Carlos

data/bin/gtk2passwordapp

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# $Date: 2009/02/19 15:50:30 $
+##########################################################
+require 'lib/global_options_variables'
+GlobalOptionsVariables.set('0.0.1',
+        <<EOT
+Usage: #{$0.sub(/^.*\//,'')} [options]
+
+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.mkdir('/gifs')
+UserSpace.copy('/gifs/logo.gif')
+require USER_CONF_DIR+CONF_FILE
+##########################################################
+require 'lib/gtk2passwordapp'
+
+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
+end

data/lib/configuration.rb

@@ -0,0 +1,49 @@
+#$Date: 2009/02/19 17:56:37 $
+# 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
+  ENTRY_WIDTH	= 275
+  LABEL_WIDTH	= 75
+  SPIN_BUTTON_LENGTH = 50
+  PAD		= 2	# cell padding
+
+  FONT_NAME	= 'Arial 10'
+
+  MAX_PASSWORD_LENGTH = 20
+  DEFAULT_PASSWORD_LENGTH = 7
+  MIN_PASSWORD_LENGTH = 3
+
+  VERIFIED_EXPIRED = 60*15 # 15 minutes
+  PASSWORD_EXPIRED = 60*60*24*30*3 # 3 months
+
+  URL_PATTERN	= Regexp.new('^https?:\/\/[^\s\']+$')
+
+  # Here you can set your browser preferences for remote control.
+  # As is, the first browser found will be used, like
+  # BROWSER = '/usr/bin/epiphany -n'
+  [
+	# browser       url remote option code
+	[ 'browser',    '--url'         ],
+	[ 'fennec',     ''              ],
+	[ 'epiphany',   '-n'            ],
+	[ 'firefox',    '-new-tab'      ],
+	[ 'opera',      ''              ]
+  ].each {|try|
+      browser = `which #{try[0]} 2> /dev/null`.strip
+      next if browser == ''
+      BROWSER = "#{browser} #{try[1]}"
+      break
+  }
+  $stderr.puts "Browser remote command: #{BROWSER}" if $trace
+
+  LOGO_IMAGE = USER_CONF_DIR+'/gifs/logo.gif'
+end
+
+def puts_bang!(h=nil, t=nil)
+  if $trace then
+    $stderr.puts h if h
+    $stderr.puts $!
+    $stderr.puts $!.backtrace
+    $stderr.puts t if t
+  end
+end

data/lib/global_options_variables.rb

@@ -0,0 +1,40 @@
+# $Date: 2009/02/14 16:30:05 $
+GEM_LIB_DIR	= File.expand_path( File.dirname(__FILE__) )
+GEM		= GEM_LIB_DIR.split(/[\/\\]/)[-2]
+USER_CONF_DIR	= ENV['HOME'] + "/.#{GEM}"
+GEM_ROOT_DIR	= GEM_LIB_DIR.sub(/\/[^\/\\]+$/,'')
+CONF_FILE	= '/configuration.rb'
+module GlobalOptionsVariables
+  def self.set( version, help=nil, additional_options={} )
+    raise "globals have been set elsewhere :-??" if $version || $quiet || $test || $trace
+    $version = version
+
+    options_map = {
+	'--help'	=> 'h',
+	'--quiet'	=> 'q',
+	'--test'	=> 't',
+	'--trace'	=> 'T',
+    }
+
+    options = ''
+    opt = nil
+    while ARGV[0]=~/^\-/ do
+      opt = ARGV.shift
+      options += (additional_options[opt])? additional_options[opt]: (options_map[opt])? options_map[opt]: opt
+    end
+
+    if help && options=~/h/ then
+      puts help if help
+      exit
+    elsif options=~/v/ then
+      puts $version
+      exit
+    end
+
+    $quiet = (options=~/q/)? true: false
+    $test = (options=~/t/)? true: false
+    $trace = (options=~/t/i)? true: false
+
+    return options
+  end
+end

data/lib/gtk2passwordapp.rb

@@ -0,0 +1,597 @@
+# $Date: 2009/02/19 20:50:22 $
+require 'lib/passwords_data'
+require 'gtk2'
+require 'find'
+
+class Gtk2PasswordApp
+  include Configuration
+
+  ABOUT	= {
+	'authors'	=> ['carlosjhr64@gmail.com'],
+	'comments'	=> "Ruby-Gtk2 Password Manager.",
+	'version'	=> $version,
+	'website'	=> 'http://ruby-gnome-apps.blogspot.com/search/label/Passwords',
+	'website-label'	=> 'Ruby Gnome Password Manager',
+	'license'	=> 'GPL',
+	'copyright'	=> '$Date: 2009/02/19 20:50:22 $'.gsub(/\s*\$\s*/,''),
+	'logo'		=> Gdk::Pixbuf.new(LOGO_IMAGE),
+  }
+
+  BUTTONS = [[ :username, :current, :url, ],[ :note, :edit, :quit, ],]
+
+  EDITOR_LABELS = [
+	:account,
+ 	:url,
+ 	:note,
+ 	:username,
+ 	:password,
+	]
+
+
+  EDITOR_BUTTONS = [
+	[ :random, :alphanum, :num, :alpha, :caps, ],
+	[ :visibility, :current, :previous, :cancel, :save, :update, ],
+	[ :delete, :cpwd, :cpph ],
+	]
+
+  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		=> 'Data File Password',
+	:cpph		=> 'Data File Passphrase',
+	:delete		=> 'Delete Account',
+  }
+
+  FONT = Pango::FontDescription.new(FONT_NAME)
+  RED = Gdk::Color.parse("#A00000")
+  BLACK = Gdk::Color.parse("#000000")
+
+  def quit_windows
+    if @editing
+      @editing.hide
+      @editing.destroy
+      @editing = nil
+    end
+    if @window
+      @window.hide
+      @window.destroy
+      @window = nil
+    end
+  end
+
+  def quick_message(message, window, title='Note', font=FONT)
+    # Create the dialog
+    dialog = Gtk::Dialog.new(
+        title,
+        window, Gtk::Dialog::DESTROY_WITH_PARENT,
+        [ Gtk::Stock::OK, Gtk::Dialog::RESPONSE_NONE ])
+
+    # Ensure that the dialog box is destroyed when the user responds.
+    dialog.signal_connect('response') { dialog.destroy }
+
+    # Add the message in a label, and show everything we've added to the dialog.
+    label = Gtk::Label.new(message)
+    label.wrap = true
+    label.modify_font(font) if font
+    dialog.vbox.add(label)
+    dialog.show_all
+  end
+
+  def 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(FONT)
+    dialog.vbox.add(label)
+    entry = Gtk::Entry.new
+    entry.visibility = false
+    entry.modify_font(FONT)
+    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
+
+  def _create_passphrase(pfile)
+    passphrase = ''
+
+    56.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 = USER_CONF_DIR+'/passphrase.txt'
+    if mv then
+      File.rename(pfile, pfile+'.bak') if File.exist?(pfile)
+      passphrase = _create_passphrase(pfile)
+    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(USER_CONF_DIR){|fn|
+      Find.prune if !(fn==USER_CONF_DIR) &&  File.directory?(fn)
+      if fn =~/[0123456789abcdef]{32}\.dat$/ then
+        return true
+      end
+    }
+    return false
+  end
+
+  def initialize
+    @updated = false	# only saves data if data updated
+    @editing = nil	# when editor window is up, this is set.
+    @verified = Time.now.to_i
+
+    @pwd = get_salt || exit
+    @pph = get_passphrase
+    @passwords = PasswordsData.new(@pwd+@pph)
+    # Password file exist?
+    if @passwords.exist? # then
+      # Yes, load passwords file.
+      @passwords.load 
+    else
+      # No, check if there is a file....
+      if has_datafile? # then
+        # Yes, it's got a datafile. Ask for password again.
+        while !@passwords.exist? do
+          @pwd = get_salt('Try again!') || exit
+          @passwords = PasswordsData.new(@pwd+@pph)
+        end
+        @passwords.load 
+      else
+      # Else, must be a new intall.
+        pwd = @pwd
+        @pwd = get_salt('Verify New Password') || exit
+        while !(pwd == @pwd) do
+          pwd = get_salt('Try again!') || exit
+          @pwd = get_salt('Verify New Password') || exit
+        end
+      end
+    end
+    # Off to the races...
+  end
+
+  def verify_user
+    now = Time.now.to_i
+    if now - @verified > VERIFIED_EXPIRED then
+      pwd0 = get_salt('Current Password')
+      return false if !pwd0
+      tries = 1
+      while !(pwd0==@pwd) do
+        tries += 1
+        pwd0 = get_salt('CURRENT PASSWORD???')
+        return false if !pwd0 || tries > 2
+      end
+    end
+    @verified = now
+    return true
+  end
+
+  def edit(combo_box, index)
+    begin
+      window = @editing
+      window.signal_connect('delete_event') { @editing = nil }
+      old_list = @passwords.accounts # dup not necessary
+
+      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
+
+      widget = {}
+      EDITOR_LABELS.each {|s|
+        hbox = Gtk::HBox.new
+        label = Gtk::Label.new(TEXT[s]+':')
+        label.modify_font(FONT)
+        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*PAD: 0)
+        widget[s].modify_font(FONT)
+        hbox.pack_start(label, false, false, PAD)
+        hbox.pack_end(pwdlength, false, false, PAD) if s == :password
+        hbox.pack_end(widget[s], false, false, PAD)
+        vbox.pack_start(hbox, false, false, PAD)
+      }
+
+      EDITOR_BUTTONS.each{|row|
+        hbox = Gtk::HBox.new
+        row.each {|s|
+          widget[s] = Gtk::Button.new(TEXT[s])
+          widget[s].child.modify_font(FONT)
+          (s==:cancel || s==:save || s==:update)?
+		hbox.pack_end(widget[s], false, false, PAD) :
+		hbox.pack_start(widget[s], false, false, PAD)
+        }
+        vbox.pack_start(hbox, false, false, PAD)
+      }
+
+      # 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
+        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) 
+              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
+          quick_message('Need url like http://www.site.com/page.html', window)
+        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'){
+        primary   = Gtk::Clipboard.get(Gdk::Selection::PRIMARY)
+        clipboard = Gtk::Clipboard.get(Gdk::Selection::CLIPBOARD)
+        account = (widget[:account].active_text)? widget[:account].active_text.strip: ''
+        primary.text = clipboard.text = @passwords.password_of(account)
+      }
+
+      # Previous
+      widget[:previous].signal_connect('clicked'){
+        primary   = Gtk::Clipboard.get(Gdk::Selection::PRIMARY)
+        clipboard = Gtk::Clipboard.get(Gdk::Selection::CLIPBOARD)
+        account = (widget[:account].active_text)? widget[:account].active_text.strip: ''
+        primary.text = clipboard.text = @passwords.previous_password_of(account)
+      }
+
+      # Change Password
+      widget[:cpwd].signal_connect('clicked'){
+        if verify_user then
+          pwd1 = get_salt('New Password') || return
+          pwd2 = get_salt('Verify') || return
+          while !(pwd1==pwd2) do
+            pwd1 = get_salt('Try again!') || return
+            pwd2 = get_salt('Verify') || return
+          end
+          @pwd = pwd1
+          @passwords.save(@pwd+@pph)
+        else
+          quit_windows
+        end
+      }
+
+      # Change Passphrase
+      widget[:cpph].signal_connect('clicked'){
+        if verify_user then
+          @pph = get_passphrase(true) # mv old passphrase? true
+          @passwords.save(@pwd+@pph)
+        else
+          quit_windows
+        end
+      }
+
+      # Save
+      widget[:save].signal_connect('clicked'){
+        window.hide
+        if @updated then
+          if verify_user then
+            @passwords.save
+            @updated = false
+            new_list = @passwords.accounts # dup not needed
+            new_list.each {|account|
+              if !old_list.include?(account) then
+                i = new_list.index(account)
+                old_list.insert(i,account)
+                combo_box.insert_text(i,account)
+              end
+            }
+            old_list.each {|account|
+              if !new_list.include?(account) then
+                i = old_list.index(account)
+                old_list.delete_at(i)
+                combo_box.remove_text(i)
+              end
+            }
+          else
+            quit_windows
+          end
+        end
+        window.destroy
+        @editing = nil
+      }
+
+      # Delete
+      widget[:delete].signal_connect('clicked'){
+        account = (widget[:account].active_text)? widget[:account].active_text.strip: ''
+        i = @passwords.accounts.index(account)
+        @passwords.delete(account)
+        widget[:account].remove_text(i)
+        @updated = true
+      }
+
+      # Cancel
+      widget[:cancel].signal_connect('clicked'){
+        window.hide
+        if @updated then
+          @passwords.load # revert
+          @updated = false
+        end
+        window.destroy
+        @editing = nil
+      }
+
+      window.show_all
+    rescue Exception
+      puts_bang!
+    end
+  end
+
+  def run
+    begin
+      @window = window  = Gtk::Window.new
+      window.signal_connect('delete_event') { quit_windows }
+
+      vbox = Gtk::VBox.new
+      window.add(vbox)
+
+      combo_box =Gtk::ComboBox.new
+      combo_box.modify_font(FONT)
+      vbox.pack_start(combo_box, false, false, PAD)
+
+      button = {}
+
+      BUTTONS.each{ |row|
+        hbox = Gtk::HBox.new
+        row.each{|b|
+          button[b] = Gtk::Button.new(TEXT[b])
+          button[b].modify_font(FONT)
+          button[b].width_request = LABEL_WIDTH
+          hbox.pack_start(button[b], false, false, PAD)
+        }
+        vbox.pack_start(hbox, false, false, PAD)
+      }
+
+      @passwords.accounts.each { |account|
+        combo_box.append_text( account )
+      }
+      combo_box.active = 0
+      button[:edit].child.modify_fg(Gtk::STATE_NORMAL, (@passwords.expired?(combo_box.active_text.strip))? RED: BLACK) if combo_box.active_text
+      combo_box.signal_connect('changed'){
+        button[:edit].child.modify_fg(Gtk::STATE_NORMAL, (@passwords.expired?(combo_box.active_text.strip))? RED: BLACK)
+      }
+      button[:username].signal_connect('clicked'){
+        primary	  = Gtk::Clipboard.get(Gdk::Selection::PRIMARY)
+        clipboard = Gtk::Clipboard.get(Gdk::Selection::CLIPBOARD)
+        account = (combo_box.active_text)? combo_box.active_text.strip: ''
+        primary.text = clipboard.text = @passwords.username_of(account)
+      }
+      button[:current].signal_connect('clicked'){
+        primary   = Gtk::Clipboard.get(Gdk::Selection::PRIMARY)
+        clipboard = Gtk::Clipboard.get(Gdk::Selection::CLIPBOARD)
+        account = (combo_box.active_text)? combo_box.active_text.strip: ''
+        primary.text = clipboard.text = @passwords.password_of(account)
+      }
+      button[:url].signal_connect('clicked'){
+        account = (combo_box.active_text)? combo_box.active_text.strip: ''
+        url = @passwords.url_of(account)
+        if url.length > 0 && url =~ URL_PATTERN then
+          system("#{BROWSER} '#{url}' > /dev/null 2>&1 &")
+        end
+      }
+      button[:note].signal_connect('clicked'){
+        account = (combo_box.active_text)? combo_box.active_text.strip: ''
+        note = @passwords.note_of(account).strip
+        note = '*** empty note ***' if note.length == 0
+        quick_message(note,window)
+      }
+      button[:edit].signal_connect('clicked'){
+        if !@editing then
+          account = (combo_box.active_text)? combo_box.active_text.strip: ''
+          i = @passwords.accounts.index(account)
+          @editing = Gtk::Window.new
+          edit(combo_box,i)
+        end
+      }
+      button[:quit].signal_connect('clicked'){ quit_windows }
+
+      if !@passwords.exist? then
+        @editing = Gtk::Window.new
+        edit(combo_box,0)
+      end
+
+      window.show_all
+    rescue Exception
+      puts_bang!
+    end
+  end
+
+  def status_icon
+    icon = Gtk::StatusIcon.new
+    icon.set_icon_name(Gtk::Stock::DIALOG_AUTHENTICATION)
+    icon.tooltip = 'Password Manager'
+    icon.signal_connect('activate') {
+      if @window then
+        quit_windows
+      else
+        menu = Gtk::Menu.new
+        @passwords.accounts.each {|account|
+          menuitem = Gtk::MenuItem.new(account)
+          menuitem.child.modify_fg(Gtk::STATE_NORMAL, RED) if @passwords.expired?(account)
+          menu.append(menuitem)
+          menuitem.signal_connect('activate'){|b|
+            primary   = Gtk::Clipboard.get(Gdk::Selection::PRIMARY)
+            clipboard = Gtk::Clipboard.get(Gdk::Selection::CLIPBOARD)
+            primary.text = clipboard.text = @passwords.password_of(b.child.text.strip)
+          }
+        }
+
+        menu.append( Gtk::SeparatorMenuItem.new )
+
+        menuitem = Gtk::MenuItem.new('Quit')
+        menuitem.signal_connect('activate'){
+          quit_windows
+          icon.set_visible(false)
+          icon = nil
+          Gtk.main_quit
+        }
+        menu.append(menuitem)
+
+        Gtk::AboutDialog.set_url_hook{|about,link| system( "#{BROWSER} '#{link}' > /dev/null 2>&1 &" ) }
+        menuitem = Gtk::MenuItem.new('About')
+        menuitem.signal_connect('activate'){
+          Gtk::AboutDialog.show(nil, ABOUT)
+        }
+        menu.append(menuitem)
+
+        menuitem = Gtk::MenuItem.new('Run')
+        menuitem.signal_connect('activate'){
+          if !@window
+            verify_user
+            run 
+          end
+        }
+        menu.append(menuitem)
+
+        menu.show_all
+        menu.popup(nil, nil, 0, 0)
+      end
+    }
+    run if !@passwords.exist?
+    Gtk.main
+  end
+end

data/lib/iocrypt.rb

@@ -0,0 +1,30 @@
+# $Date: 2009/02/18 00:41:54 $
+require 'yaml'
+require 'rubygems'
+require 'crypt/blowfish'
+
+class IOCrypt
+  def initialize(passphrase)
+    @blowfish = Crypt::Blowfish.new(passphrase[0..55])  
+  end
+
+  def load(dumpfile)
+    data = nil
+
+    File.open(dumpfile,'r'){|fh|
+      data = YAML.load( @blowfish.decrypt_string( fh.read ) )
+    }
+
+    return data
+  end
+
+  def dump(dumpfile, data)
+    count = nil
+
+    File.open(dumpfile,'w') do |fh|
+      count = fh.write( @blowfish.encrypt_string( YAML.dump( data ) ) )
+    end
+
+    return count
+  end
+end

data/lib/passwords_data.rb

@@ -0,0 +1,110 @@
+# $Date: 2009/02/18 16:07:01 $
+require 'lib/iocrypt'
+require 'digest/md5'
+
+class PasswordsData
+  include Configuration
+  attr_accessor :account
+  attr_reader :data
+
+  PASSWORD	= 0
+  PREVIOUS	= 1
+  NOTE		= 2
+  USERNAME	= 3
+  URL		= 4
+  LAST_UPDATE	= 5
+
+  def _reset(passphrase)
+    raise "Need a good passphrase" if !passphrase || passphrase.length < 7
+    @passphrase = passphrase[0..55]
+    @dumpfile = USER_CONF_DIR + '/' + Digest::MD5.hexdigest(@passphrase) + '.dat'
+  end
+
+  def initialize(passphrase)
+    _reset(passphrase)
+    @data = {}
+  end
+
+  def exist?
+    File.exist?(@dumpfile)
+  end
+
+  def load(passphrase = nil)
+    _reset(passphrase) if passphrase 
+    raise "Wrong passphrase" if !exist?
+    iocrypt = IOCrypt.new(@passphrase)
+    @data = iocrypt.load(@dumpfile)
+  end
+
+  def save(passphrase = nil)
+    # just in case, keep a backup
+    File.rename(@dumpfile, @dumpfile+'.bak') if File.exist?(@dumpfile)
+    _reset(passphrase) if passphrase 
+    iocrypt = IOCrypt.new(@passphrase)
+    iocrypt.dump(@dumpfile, @data)
+    File.chmod(0600, @dumpfile)
+  end
+
+  def add(account)
+    raise "Pre-existing" if @data[account]
+    raise "Can't have nil account" if !account
+    @data[account] = ['','','','','']
+  end
+
+  def accounts
+    @data.keys.sort
+  end
+
+  def include?(account)
+    return (@data[account])? true: false
+  end
+
+  def verify?(account,password)
+    return @data[account][PASSWORD] == password
+  end
+
+  def delete(account)
+    raise "#{account} not found" if !@data[account]
+    @data.delete(account)
+  end
+
+  def url_of(account, url=nil)
+    raise "#{account} not found" if !@data[account]
+    @data[account][URL] = url if url
+    return @data[account][URL]	|| ''
+  end
+
+  def expired?(account)
+    raise "#{account} not found" if !@data[account]
+    return true if !@data[account][LAST_UPDATE] || ((Time.now.to_i - @data[account][LAST_UPDATE]) > PASSWORD_EXPIRED)
+    return false
+  end
+
+  def password_of(account, p=nil)
+    raise "#{account} not found" if !@data[account]
+    if p then
+      @data[account][PREVIOUS] = @data[account][PASSWORD]
+      @data[account][PASSWORD] = p
+      @data[account][LAST_UPDATE] = Time.now.to_i
+    end
+    return @data[account][PASSWORD]	|| ''
+  end
+
+  # previous password
+  def previous_password_of(account)
+    raise "#{account} not found" if !@data[account]
+    return @data[account][PREVIOUS]	|| ''
+  end
+
+  def note_of(account, n=nil)
+    raise "#{account} not found" if !@data[account]
+    @data[account][NOTE] = n if n
+    return @data[account][NOTE]	|| ''
+  end
+
+  def username_of(account, usr=nil)
+    raise "#{account} not found" if !@data[account]
+    @data[account][USERNAME] = usr if usr 
+    return @data[account][USERNAME]	|| ''
+  end
+end

data/lib/setup_user_space.rb

@@ -0,0 +1,37 @@
+# $Date: 2009/02/19 15:49:32 $
+module UserSpace
+  # provided by caller (global_options_variables):
+  # USER_CONF_DIR
+  # GEM_LIB_DIR
+  # CONF_FILE
+
+  def self.mkdir(subdir='')
+    dir = USER_CONF_DIR+subdir
+    Dir.mkdir(dir) if !File.exist?(dir)
+  end
+
+  def self.cp(rfile,wfile)
+    if !File.exist?(wfile) then
+      File.open(rfile, 'r'){|fhr|
+        File.open(wfile, 'w'){|fhw|
+          fhr.each{|ln| fhw.puts ln}
+        }
+      }
+      File.chmod(0600, wfile) # rw to user only
+    end
+  end
+
+  def self.copy(rfile, wfile=nil)
+    wfile = rfile if !wfile
+    self.cp(GEM_ROOT_DIR+rfile, USER_CONF_DIR+wfile)
+  end
+
+  def self.cp_conf
+    self.cp(GEM_LIB_DIR+CONF_FILE, USER_CONF_DIR+CONF_FILE)
+  end
+
+  def self.setup
+    self.mkdir
+    self.cp_conf
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: gtk2passwordapp
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- carlosjhr64@gmail.com
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-15 00:00:00 -08:00
+default_executable: gtk2youtubeapp
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: crypt
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A Ruby-Gtk2 application to keep passwords. Uses gem crypt/blofish to encrypt data. Requires crypt and gtk2.
+email: carlosjhr64@gmail.com
+executables: 
+- gtk2passwordapp
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/configuration.rb
+- lib/global_options_variables.rb
+- lib/gtk2passwordapp.rb
+- lib/iocrypt.rb
+- lib/passwords_data.rb
+- lib/setup_user_space.rb
+- gifs/logo.gif
+- README.txt
+has_rdoc: false
+homepage: http://ruby-gnome-apps.blogspot.com/search/label/Password
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- ruby-gtk2
+rubyforge_project: gtk2passwordapp
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Ruby-Gtk2 application to maitain passwords.
+test_files: []
+