passvault 0.1.2

data/lib/crypto.rb

@@ -0,0 +1,146 @@
+require_relative 'bytes_manip'
+require 'openssl'
+
+# This class contains the implementation of cryptographics utilities and functions.
+#
+# All keys used to communicate with the tag (Triple DES keys) are always
+# represented as 16 bytes long byte-strings. Byte-strings is what the OpenSSL
+# library use, so it makes sense to use that. But often, it is useful to
+# manipulate those as array of bytes. The functions String.unpack() and
+# Array.pack() ((un)pack into(from) a byte string) are very useful for this,
+# especially with 'C*' as argument .
+#
+# The card is only able to perform TDES encryption (not decryption) with 2 keys
+# (keying option 2, aka 2TDEA). When the two keys are identical, the result is
+# the same as plain DES. We elected to use only TDES on the user end (which is
+# presumably also the case on the tag's end). Therefore all TDES and DES keys
+# are 16-byte key. A 16 byte DES key is formed by concatening the 8 byte DES key
+# to itself.
+#
+# AES encryption is used to encrypt the credentials stored on the tag.
+#
+# OpenSSL modes:
+#
+# <tt>DES-EDE-CBC</tt> = Triple DES (Encrypt Decrypt Encrypt) in the regular CBC
+# mode (send for encryption, receive for decryption). The IV is zeroed by
+# default.
+#
+# <tt>AES-256-CBC</tt> = AES with 256 bit keys in the regular CBC mode. The IV
+# is zeroed by default.
+
+module Crypto
+  include BytesManipulation
+
+  # Block length for DES.
+  DES_BLEN = 8
+
+  # An IV of +DES_BLEN+ zeroes.
+  ZERO_IV = Array.new(DES_BLEN, 0).pack("C*")
+
+  # Size of the HMAC (SHA-256) digest.
+  HMAC_LEN = 32
+
+  # Deciphers a byte string using 3DES in CBC receive mode. Returns a byte
+  # string.
+  def decipher_receive(bytes, key)
+    des = OpenSSL::Cipher.new('DES-EDE-CBC')
+    des.decrypt
+    des.key = key
+    des.padding = 0 # no padding
+    return des.update(bytes) + des.final
+  end
+
+  # Deciphers a byte string using 3DES in CBC send mode.
+  def decipher_send(bytes, key)
+    mix = ZERO_IV
+    partial_block_count =  (bytes.bytesize % DES_BLEN > 0) ? 1 : 0
+    nblocks = bytes.length / DES_BLEN + partial_block_count
+    out = Array.new(nblocks)
+
+    out.each_index do |i|
+      block = bytes.byteslice(i*DES_BLEN, DES_BLEN)
+      block = bs_xor(block, mix)
+      block = decipher_receive(block, key)
+      out[i] = block
+      mix = block
+    end
+    return out.reduce("", :+)
+  end
+
+  # The following enciphering functions are not needed by the passworld vault,
+  # but are always nice to have to perform some verifications.
+
+  # Enciphers a byte string using 3DES in CBC send mode. Returns a byte
+  # string. Unused.
+  def encipher_send(bytes, key)
+    des = OpenSSL::Cipher.new('DES-EDE-CBC')
+    des.encrypt
+    des.key = key
+    des.padding = 0 # no padding
+    return des.update(bytes) + des.final
+  end
+
+  # Enciphers a byte string using 3DES in CBC receive mode. Returns a byte
+  # string. Unused.
+  def encipher_receive(bytes, key)
+    mix = ZERO_IV
+    partial_block_count = (bytes.bytesize % DES_BLEN > 0) ? 1 : 0
+    nblocks = bytes.length / DES_BLEN + partial_block_count
+    out = Array.new(nblocks)
+
+    out.each_index do |i|
+      block1 = bytes.byteslice(i*DES_BLEN, DES_BLEN)
+      block = encipher_send(block1, key)
+      block = bs_xor(block, mix)
+      out[i] = block
+      mix = block1
+    end
+    return out.reduce("", :+)
+  end
+
+  # Derive a key of the given size using the PBKDF2 derivation function, from
+  # given pass and salt. 50k iterations of SHA-256 are used.
+  def derive_key(pass, salt, key_size)
+    sha256_d = OpenSSL::Digest::SHA256.new
+    # (pass, salt, iter, keylength, digest)
+    return OpenSSL::PKCS5::pbkdf2_hmac(pass, salt, 50000, key_size, sha256_d)
+  end
+
+  # Derive a DESFire Triple DES key. This is similar to <tt>derive_key()</tt>
+  # with +key_size+ = 16, excepted that we overwrite the parity bits of the
+  # key. Anyone can ask to get those bits from the tag ("key versionning"
+  # feature). As such, keeping the orignal parity bits makes the key less
+  # secure.
+  def derive_desfire_key(pass, salt)
+    key = derive_key(pass, salt, 16)
+    array = key.unpack('C*')
+    array.map! { |e| e & 0xFE }
+    return array.pack('C*')
+  end
+
+  # Enciphers using AES with 256 bits key in CBC (send) mode.
+  def aes_encipher(bytes, key)
+    aes = OpenSSL::Cipher.new('AES-256-CBC')
+    aes.encrypt
+    aes.key = key
+    aes.padding = 0 # no padding
+    return aes.update(bytes) + aes.final
+  end
+
+  # Deciphers using AES with 256 bits key in CBC (receive) mode.
+  def aes_decipher(bytes, key)
+    aes = OpenSSL::Cipher.new('AES-256-CBC')
+    aes.decrypt
+    aes.key = key
+    aes.padding = 0 # no padding
+    return aes.update(bytes) + aes.final
+  end
+
+  # Computes a HMAC digest on given data using given key. Uses SHA-1 as
+  # digest.
+  def hmac(bytes, key)
+    sha256_d = sha256_d = OpenSSL::Digest::SHA256.new
+    return OpenSSL::HMAC.digest(sha256_d, key, bytes)
+  end
+
+end

data/lib/file_access.rb

@@ -0,0 +1,103 @@
+module Rights
+
+# Communication setting: plain (unencrypted, unauthenticated) communication.
+CS_PLAIN      = 0x0
+
+# Communication setting: unencrypted, authenticated communication.
+CS_PLAIN_MAC  = 0x1
+
+# Communication setting: encrypted, authenticated communication.
+CS_CIPHERED   = 0x3
+
+# Used in file access rights in place of a key number, to allow unauthenticated
+# access.
+FREE_ACCESS = 0xE
+
+# Used in file access rights in place of a key number, to indicate that no key
+# is authorized.
+DENY_ACCESS = 0xF
+
+# The file access settings determine the keys needed to authenticate in order to
+# perform some operations on files (inside an application), and how the file
+# transfer are performed. Those two separate concepts are called in the DESFire
+# documentation "file access rights" and "communication settings".
+#
+# The keys can be a key number from the application (from 0x0 to 0xD) or the
+# constants +FREE_ACCESS+ (no authentication needed) or +DENY_ACCESS+ (the operation
+# cannot be performed) (constants defined in the +Rights+ module).
+class FileAccess
+
+  # Key to be able to read.
+  attr_reader :read
+
+  # Key to be able to write.
+  attr_reader :write
+
+  # Key to be able to read and write.
+  attr_reader :rw
+
+  # Key to change the file access rights.
+  attr_reader :change
+
+  # Do the data transfer to/from the file need to authenticated or ciphered? The
+  # valid values are the <tt>CS_...</tt> constants defined in the +Rights+
+  # module. +com_set+ stands for "communication settings".
+  attr_reader :com_set
+
+  # The constructor takes a hash of parameters, which correspond to the class
+  # attributes. See the class documentation for an explanation of valid key
+  # values.
+  def initialize(hash={})
+    @read = hash[:read] || DENY_ACCESS
+    @write = hash[:write] || DENY_ACCESS
+    @rw = hash[:rw] || DENY_ACCESS
+    @change = hash[:change] || DENY_ACCESS
+    @com_set = hash[:com_set] || CS_CIPHERED
+  end
+
+  # Builds and returns a +FileAccess+ object from the byte array returned by the
+  # +GET_FILE_SETTINGS+ command.
+  def self.from_a(ba)
+    FileAccess.new(
+      :read     => ba[3] >> 4,
+      :write    => ba[3] % 16,
+      :rw       => ba[2] >> 4,
+      :change   => ba[2] % 16,
+      :com_set  => ba[1])
+  end
+
+  # Returns a two-byte little-endian view of the access rights (not the
+  # communication settings), fit to be used as a command parameter.
+  def to_a
+   [rw*16 + change, read*16 + write]
+  end
+
+  # Can the file be read when authenticated with the given key, and how? Returns
+  # either +false+ or a <tt>CS_...</tt> constant (see +Rights+ module
+  # documentation).
+  def read_type(key_no)
+    if @read == key_no or @rw == key_no
+      return @com_set
+    elsif @read == FREE_ACCESS or @rw == FREE_ACCESS
+      return CS_PLAIN
+    else
+      return false
+    end
+  end
+
+  # Can the file be written when authenticated with the given key, and how?
+  # Returns either +false+ or a <tt>CS_...</tt> constant (see +Rights+ module
+  # documentation).
+  def write_type(key_no)
+    if @write == key_no or @rw == key_no
+      return @com_set
+    elsif @write == FREE_ACCESS or @rw == FREE_ACCESS
+      return CS_PLAIN
+    else
+      return false
+    end
+  end
+
+end
+
+end

data/lib/gui.rb

@@ -0,0 +1,270 @@
+require "wx"
+require_relative 'vault'
+include Wx
+
+module VaultGUI
+  TIMEOUT = 300
+
+  # Initialize the vault
+  @@vault = Vault.new
+
+  # Return the vault associated to the GUI.
+  def self.vault
+    return @@vault
+  end
+
+  class GUILauncher < App
+    def on_init
+      GUI.new.show
+    end
+  end
+
+  class GUI < Frame
+    def initialize
+      super(nil, 0, "Password Vault GUI",
+        :style => DEFAULT_FRAME_STYLE ^ RESIZE_BORDER ^ MAXIMIZE_BOX)
+
+      ask_password()
+
+      vbox = BoxSizer.new(VERTICAL)
+      pl = PasswordList.new(self)
+      evt_list_item_activated(pl) { |event|
+        item_activated(pl.get_item(event.get_index, 0).get_text())
+      }
+      panel = Panel.new(self)
+
+      hbox = BoxSizer.new(HORIZONTAL)
+      add_button = Button.new(panel, :label=>"ADD", :size => [80, 20])
+      evt_button(add_button) {
+        check_and_reset_timer()
+        add_pushed(pl)
+      }
+      remove_button = Button.new(panel, :label=>"REMOVE", :size => [80, 20])
+      evt_button(remove_button) {
+        check_and_reset_timer()
+        remove_pushed(pl)
+      }
+      edit_button = Button.new(panel, :label=>"EDIT", :size => [80, 20])
+      evt_button(edit_button) {
+        check_and_reset_timer()
+        edit_pushed(pl)
+      }
+      hbox.add(add_button)
+      hbox.add(remove_button)
+      hbox.add(edit_button)
+      panel.set_sizer(hbox)
+
+      vbox.add(pl)
+      vbox.add(panel)
+      self.set_sizer(vbox)
+      vbox.set_size_hints( self )
+      self.centre
+
+      evt_close() { |event|
+        VaultGUI.vault.destroy
+        self.destroy
+      }
+
+      @timer = Time.now.to_i
+    end
+
+    def ask_password()
+      password_popup = PasswordPopup.new(self)
+      if password_popup.show_modal == ID_OK
+        pass_candidate = password_popup.get_value()
+        begin
+          VaultGUI.vault.authenticate(pass_candidate)
+        rescue => e
+          Kernel.raise e unless e.message == Vault::AUTHENTICATION_ERROR
+          ErrorPopup.new("Error: wrong password!", "Error: wrong password!", true)
+        end
+      else
+        Kernel.exit
+      end
+    end
+
+    def check_and_reset_timer()
+      now = Time.now.to_i
+      if now - @timer > TIMEOUT
+        VaultGUI.vault.deauthenticate()
+        ask_password()
+      end
+      @timer = now
+    end
+
+    def item_activated(name)
+      info_popup = ViewPopup.new(self)
+      loginPassword = VaultGUI.vault.credential(name)
+      info_popup.set_name_value(name)
+      info_popup.set_login_value(loginPassword[0])
+      info_popup.set_password_value(loginPassword[1])
+      info_popup.show
+      evt_button(info_popup) {
+        info_popup.destroy
+      }
+    end
+
+    def add_pushed(pl)
+      add_popup = AddPopup.new(self)
+      add_popup.show
+      evt_button(add_popup) {
+        new_name = add_popup.get_name_value
+        new_login = add_popup.get_login_value
+        new_password = add_popup.get_password_value
+        begin
+          VaultGUI.vault.add(new_name, new_login, new_password)
+          pl.insert_item(ListItem.new)
+          add_popup.destroy
+        rescue => e
+          display_error_if_needed(e)
+          add_popup.destroy
+        end
+      }
+    end
+
+    def remove_pushed(pl)
+      selection = pl.get_selections
+      if selection.length > 0
+        index_deleted = selection[0]
+        deleted = pl.get_item(index_deleted, 0).get_text
+        pl.delete_item(index_deleted)
+        VaultGUI.vault.remove(deleted)
+      end
+    end
+
+    def edit_pushed(pl)
+      selection = pl.get_selections
+      if selection.length > 0
+        index_edited = selection[0]
+        edit_popup = EditPopup.new(self)
+        edit_popup.show
+        evt_button(edit_popup) {
+          name = pl.get_item(index_edited, 0).get_text
+          new_login = edit_popup.get_login_value
+          new_password = edit_popup.get_password_value
+          begin
+            VaultGUI.vault.edit(name, new_login, new_password)
+            edit_popup.destroy
+          rescue => e
+            display_error_if_needed(e)
+          end
+        }
+      end
+    end
+
+    def display_error_if_needed(e)
+      if e.class == Vault::CredentialError
+        ErrorPopup.new(e.message, "Credential error", false)
+      else
+        Kernel.raise e
+      end
+    end
+  end
+
+  class PasswordList < ListCtrl
+    def initialize(parent)
+      super(parent,
+        :style=>LC_REPORT | LC_VIRTUAL | LC_SINGLE_SEL,
+        :size=>[240, 240])
+      insert_column(0, "Name")
+      set_column_width(0, 240)
+      set_item_count(VaultGUI.vault.credentials_names.count)
+    end
+
+    def on_get_item_text(item, column)
+      return VaultGUI.vault.credentials_names.to_a[item]
+    end
+  end
+
+  class ErrorPopup < MessageDialog
+    def initialize (message, caption, kill)
+      super(nil,
+        :message => message,
+        :caption => caption,
+        :style => OK | ICON_ERROR)
+      if self.show_modal == ID_OK && kill
+        VaultGUI.vault.destroy
+        Kernel.exit
+      end
+    end
+  end
+
+  class PasswordPopup < TextEntryDialog
+    def initialize(parent)
+      super(parent,
+        :message => "Enter your password:",
+        :caption => "Enter your password",
+        :style => OK | TE_PASSWORD)
+    end
+  end
+
+  class InfoPopup < Frame
+    def initialize(parent, title, edit_name_tf, edit_login_tf, edit_password_tf)
+      super(parent, 0, title,
+        :style => DEFAULT_FRAME_STYLE ^ RESIZE_BORDER ^ MAXIMIZE_BOX)
+      panel = Panel.new(self)
+      namel = StaticText.new(panel, 0, "Name", :style => ALIGN_CENTER)
+      @name_tf = TextCtrl.new(panel, 0)
+      @name_tf.set_editable(edit_name_tf)
+      loginl = StaticText.new(panel, 0, "Login", :style => ALIGN_CENTER)
+      @login_tf = TextCtrl.new(panel, 0)
+      @login_tf.set_editable(edit_login_tf)
+      password_l = StaticText.new(panel, 0, "Password", :style => ALIGN_CENTER)
+      @password_tf = TextCtrl.new(panel, 0, :style => TE_PASSWORD)
+      @password_tf.set_editable(edit_password_tf)
+      okb = Button.new(panel, 0, "OK")
+      vbox = BoxSizer.new(VERTICAL)
+      vbox.add(namel)
+      vbox.add(@name_tf)
+      vbox.add(loginl)
+      vbox.add(@login_tf)
+      vbox.add(password_l)
+      vbox.add(@password_tf)
+      vbox.add(okb)
+      panel.set_sizer(vbox)
+      self.centre
+    end
+
+    def get_name_value()
+      return @name_tf.get_value
+    end
+
+    def get_login_value()
+      return @login_tf.get_value
+    end
+
+    def get_password_value()
+      return @password_tf.get_value
+    end
+
+    def set_name_value(name)
+      @name_tf.set_value(name)
+    end
+
+    def set_login_value(login)
+      @login_tf.set_value(login)
+    end
+
+    def set_password_value(password)
+      @password_tf.set_value(password)
+    end
+  end
+
+  class EditPopup < InfoPopup
+    def initialize(parent)
+      super(parent, "Edit entry", false, true, true)
+    end
+  end
+
+  class AddPopup < InfoPopup
+    def initialize(parent)
+      super(parent, "Add new entry", true, true, true)
+    end
+  end
+
+  class ViewPopup < InfoPopup
+    def initialize(parent)
+      super(parent, "View entry", false, false, false)
+    end
+  end
+end