adamantite 0.0.2 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12c65083b751c2460cbc017507793dd3202f27c701b58a1c6b7d7d0612a683ab
-  data.tar.gz: 8c7d30ff3442a5d137058e00ccf0f1d3ee619c55214ba98feea29ed2a9caa66e
+  metadata.gz: 47190df18bbcffa68fd20d16d9ffb048f6f7b0b521104727f3e849a40aa29b48
+  data.tar.gz: 6acad9247d871f293b81f33976ce37b6465e043afacf5849fa31edf8640475ce
 SHA512:
-  metadata.gz: 88eefbbf38673ff319d324bf51d101a2a6d0ba87a3f614bcdf8bbf1804bbcfd969ac70c7420bb82d0f17917d181f792bfca6a9d5ec6a0cc325c9da00d24972f6
-  data.tar.gz: d2ae10748dc73c4f9d83984ca6e38d279b9a182893f311cb41f675b0c35e6ac290451292a3b15817f254a0ebb373d3f5b7f86cdc9073afb061b7ec899d993b6a
+  metadata.gz: 36b1e5ac28a539c7a2e5461bcfa4b0d0c512ae572ff8e8b2b4faf56b52a9212e0d2566e89c963b7347782d03a43cfdde3179289a2f0b73a3dd582e7855a5be51
+  data.tar.gz: 7a46bbccbf113303a4ed2f6db562ecd4c59f4fbdf8abcaff582e9c7e0425869b02f4b1a3a778f356ce22f22196ffabff31cdb40234029e95f783584c538cbb74

data/bin/adamantite

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
-require "adamantite"
+# frozen_string_literal: true
 
-AdamantiteApp.launch
+require 'adamantite'
+
+Adamantite::AdamantiteApp.launch

data/lib/adamantite.rb

@@ -1,134 +1,138 @@
-require "glimmer-dsl-libui"
-require "bcrypt"
-require "openssl"
-require "base64"
-require "json"
-require "io/console"
+# frozen_string_literal: true
 
-require "file_utils/file_utils"
-require "pw_utils/pw_utils"
-require "base/adamantite"
-require "gui/screen/login_screen"
-require "gui/screen/copy_screen"
-require "gui/screen/show_screen"
-require "gui/screen/set_master_password_screen"
-require "gui/screen/update_master_password_screen"
-require "gui/request/login_request"
-require "gui/request/add_password_request"
-require "gui/request/update_master_password_request"
-require "gui/request/set_master_password_request"
+require 'glimmer-dsl-libui'
+require 'bcrypt'
+require 'openssl'
+require 'base64'
+require 'json'
+require 'io/console'
 
-include Adamantite::FileUtils
-include Adamantite::PWUtils
+require 'fileutils'
+require 'file_utils/adamantite_file_utils'
+require 'base/adamantite'
+require 'base/password_object'
+require 'gui/screen/login_screen'
+require 'gui/screen/copy_screen'
+require 'gui/screen/show_screen'
+require 'gui/screen/set_master_password_screen'
+require 'gui/screen/update_master_password_screen'
+require 'gui/request/login_request'
+require 'gui/request/add_password_request'
+require 'gui/request/update_master_password_request'
+require 'gui/request/set_master_password_request'
+require 'gui/form/password_object_form_window'
 
-class AdamantiteApp
-  include Glimmer::LibUI::Application
+module Adamantite
+  class AdamantiteApp
+    include Glimmer::LibUI::Application
+    include Adamantite::AdamantiteFileUtils
 
-  attr_accessor :add_password_request, :stored_passwords
+    attr_accessor :add_password_request, :stored_passwords
 
-  before_body do
-    if !pw_file_exists?('master')
-      set_master_password_request = Adamantite::GUI::Request::SetMasterPasswordRequest.new
-      set_master_password_screen(set_master_password_request: set_master_password_request).show
-    end
+    before_body do
+      unless master_password_exists?
+        set_master_password_request = GUI::Request::SetMasterPasswordRequest.new
+        set_master_password_screen(set_master_password_request: set_master_password_request).show
+      end
 
-    login_request = Adamantite::GUI::Request::LoginRequest.new
-    login_screen(login_request: login_request).show
+      login_request = GUI::Request::LoginRequest.new
+      login_screen(login_request: login_request).show
 
-    if !login_request.authenticated
-      exit(0)
-    end
+      unless login_request.authenticated
+        exit(0)
+      end
 
-    @stored_passwords = get_stored_pws.map do |title|
-      pw_info = get_pw_file(title)
-      [title, pw_info["username"], 'Copy', 'Show', 'Delete']
+      @adamantite = login_request.adamantite
+      @stored_passwords = @adamantite.stored_passwords.map do |stored_password|
+        [stored_password[:website_title], stored_password[:username], 'Edit', 'Copy', 'Show', 'Delete']
+      end
+      @master_password = @adamantite.master_password
+      @master_password_salt = @adamantite.master_password_salt
+      @add_password_request = GUI::Request::AddPasswordRequest.new(@master_password, @master_password_salt)
     end
-    @master_password = login_request.master_password
-    @master_password_salt = login_request.master_password_salt
-    @adamantite_object = Adamantite::Base::Adamantite.new(@master_password)
-    @adamantite_object.authenticate!
-    @add_password_request = Adamantite::GUI::Request::AddPasswordRequest.new(@master_password, @master_password_salt)
-  end
 
-  body {
-    window('Adamantite', 600, 400) {
-      margined true
+    body do
+      window('Adamantite', 800, 400) do
+        margined true
 
-      vertical_box {
-        table {
-          text_column('Title')
-          text_column('Username')
-          button_column('Copy') {
-            on_clicked do |row|
-              password_title = @stored_passwords[row].first
-              pw_info = get_pw_file(password_title)
-              stored_pw_selection = decrypt_pw(pw_info["iv"], pw_info["password"], @master_password, @master_password_salt)
-              IO.popen('pbcopy', 'w') { |f| f << stored_pw_selection }
-              copy_screen(password_title: password_title).show
+        vertical_box do
+          table do
+            text_column('Title')
+            text_column('Username')
+            button_column('Edit') do
+              on_clicked do |row|
+                on_save = lambda do |password_object|
+                  stored_password = []
+                  stored_password << password_object.website_title
+                  stored_password << password_object.username
+                  stored_password << 'Edit'
+                  stored_password << 'Copy'
+                  stored_password << 'Show'
+                  stored_password << 'Delete'
+                  @stored_passwords[password_object.row_index] = stored_password
+                  adamantite_stored_password = {
+                    'dir_name': password_object.dir_name,
+                    'website_title': password_object.website_title,
+                    'username': @adamantite.retrieve_password_info(password_object.dir_name, 'username')
+                  }
+                  @adamantite.stored_passwords[password_object.row_index] = adamantite_stored_password
+                end
+                website_title = @stored_passwords[row][0]
+                username = @stored_passwords[row][1]
+                dir_name = @adamantite.stored_passwords[row][:dir_name]
+                password = @adamantite.retrieve_password_info(dir_name, 'password')
+                password_object = Base::PasswordObject.new(website_title, username, password, password, row, dir_name)
+                password_object_form_window(adamantite: @adamantite, on_save: on_save, password_object: password_object).show
+              end
+            end
+            button_column('Copy') do
+              on_clicked do |row|
+                IO.popen('pbcopy', 'w') do |f|
+                  dir_name = @adamantite.stored_passwords[row][:dir_name]
+                  f << @adamantite.retrieve_password_info(dir_name, 'password')
+                end
+                copy_screen(password_title: @stored_passwords[row].first).show
+              end
             end
-          }
-          button_column('Show') {
-            on_clicked do |row|
-              pw_info = get_pw_file(@stored_passwords[row].first)
-              stored_pw_selection = decrypt_pw(pw_info["iv"], pw_info["password"], @master_password, @master_password_salt)
-              show_screen(password: stored_pw_selection).show
+            button_column('Show') do
+              on_clicked do |row|
+                dir_name = @adamantite.stored_passwords[row][:dir_name]
+                show_screen(password: @adamantite.retrieve_password_info(dir_name, 'password')).show
+              end
             end
-          }
-          button_column('Delete') {
-            on_clicked do |row|
-              delete_pw_file(@stored_passwords[row].first)
-              @stored_passwords.delete_at(row)
+            button_column('Delete') do
+              on_clicked do |row|
+                @adamantite.delete_password(@adamantite.stored_passwords[row][:dir_name])
+                @stored_passwords.delete_at(row)
+              end
             end
-          }
-
-          cell_rows <=> [self, :stored_passwords]
-
-        }
-        vertical_box {
-          form {
-            entry {
-              label 'Website Title'
-              text <=> [@add_password_request, :website_title]
-            }
-            entry {
-              label 'Username'
-              text <=> [@add_password_request, :username]
-            }
-            password_entry {
-              label 'Password'
-              text <=> [@add_password_request, :password]
-            }
-            password_entry {
-              label 'Confirm Password'
-              text <=> [@add_password_request, :password_confirmation]
-            }
-          }
-          horizontal_box {
-            button('Add Password') {
+            cell_rows <=> [self, :stored_passwords]
+          end
+          horizontal_box do
+            button('Add Password') do
               on_clicked do
-                @add_password_request.confirm_and_add_password!
-                if @add_password_request.password_saved
-                  new_stored_password = [@add_password_request.website_title, @add_password_request.username]
-                  new_stored_password << 'Copy'
-                  new_stored_password << 'Show'
-                  new_stored_password << 'Delete'
-                  @stored_passwords << new_stored_password
-                  @add_password_request.website_title = ''
-                  @add_password_request.username = ''
-                  @add_password_request.password = ''
-                  @add_password_request.password_confirmation = ''
+                on_save = lambda do |password_object|
+                  stored_password = []
+                  stored_password << password_object.website_title
+                  stored_password << password_object.username
+                  stored_password << 'Edit'
+                  stored_password << 'Copy'
+                  stored_password << 'Show'
+                  stored_password << 'Delete'
+                  @stored_passwords << stored_password
                 end
+                password_object_form_window(adamantite: @adamantite, on_save: on_save).show
               end
-            }
-            button('Update Master Password') {
+            end
+            button('Update Master Password') do
               on_clicked do
-                update_master_password_request = Adamantite::GUI::Request::UpdateMasterPasswordRequest.new(@adamantite_object)
+                update_master_password_request = GUI::Request::UpdateMasterPasswordRequest.new(@adamantite)
                 update_master_password_screen(update_master_password_request: update_master_password_request).show
               end
-            }
-          }
-        }
-      }
-    }
-  }
+            end
+          end
+        end
+      end
+    end
+  end
 end

data/lib/base/adamantite.rb

@@ -1,59 +1,158 @@
-require "file_utils/file_utils"
-require "pw_utils/pw_utils"
+# frozen_string_literal: true
 
-include Adamantite::FileUtils
-include Adamantite::PWUtils
+require 'file_utils/adamantite_file_utils'
+require 'rbnacl'
+require 'base64'
 
 module Adamantite
   module Base
     class Adamantite
+      include AdamantiteFileUtils
 
-      attr_accessor :authenticated
+      attr_reader :authenticated, :master_password, :master_password_salt, :stored_passwords
 
-      def initialize(master_pw)
-        @master_pw = master_pw
+      OPSLIMIT = 2**20
+      MEMLIMIT = 2**24
+      DIGEST_SIZE = 32
+
+      def initialize(master_password)
+        @master_password = master_password
         @authenticated = false
-        @master_pw_exists = pw_file_exists?('master')
       end
 
       def authenticate!
-        return false unless @master_pw_exists
-        master_pw_info = get_master_pw_info
-        master_pw_hash = master_pw_info['password']
-        master_pw_salt = master_pw_info['salt']
-        master_pw_comparator = generate_master_pw_comparator(master_pw_hash)
-
-        if master_pw_comparator == @master_pw + master_pw_salt
-          @authenticated = true
-          @master_pw_hash = master_pw_hash
-          @master_pw_salt = master_pw_salt
-          @stored_passwords = get_stored_pws
+        if master_password_exists?
+          master_password_salt = get_master_password_salt
+          master_encrypted_vault_key = get_master_encrypted_vault_key
+          entered_master_password_hash = rbnacl_scrypt_hash(@master_password, master_password_salt)
+          vault = rbnacl_box(entered_master_password_hash)
+
+          begin
+            @master_vault_key = vault.decrypt(master_encrypted_vault_key)
+            @authenticated = true
+            @master_password_salt = master_password_salt
+            @vault = rbnacl_box(@master_vault_key)
+            update_stored_passwords!
+            true
+          rescue RbNaCl::CryptoError
+            false
+          end
+        else
+          false
+        end
+      end
+
+      def save_password(website_title, username, password, password_confirmation)
+        return unless password == password_confirmation && authenticated?
+
+        encrypted_file_name_ascii_8bit = @vault.encrypt(website_title)
+        dir_name = Base64.urlsafe_encode64(encrypted_file_name_ascii_8bit)
+        make_password_dir(dir_name)
+        write_to_file(password_file(dir_name, 'username'), @vault.encrypt(username), true)
+        write_to_file(password_file(dir_name, 'password'), @vault.encrypt(password), true)
+        update_stored_passwords!
+        dir_name
+      end
+
+      def delete_password(password_dir_name)
+        FileUtils.remove_entry_secure(password_file(password_dir_name))
+        update_stored_passwords!
+      end
+
+      def retrieve_password_info(website_title, info_name)
+        return unless authenticated?
+
+        @vault.decrypt(read_file(password_file(website_title, info_name), true))
+      end
+
+      def serialize_master_password(master_password, master_password_confirmation)
+        if master_password == master_password_confirmation
+          master_password_salt = rbnacl_random_bytes
+          master_password_hash = rbnacl_scrypt_hash(master_password, master_password_salt)
+          vault_key = rbnacl_random_bytes
+          vault = rbnacl_box(master_password_hash)
+          encrypted_vault_key = vault.encrypt(vault_key)
+          make_pwmanager_dir
+          write_master_info(master_password_salt, encrypted_vault_key)
           true
         else
           false
         end
       end
 
-      def update_master_password!(new_master_pw, new_master_pw_confirmation)
-        return false unless new_master_pw == new_master_pw_confirmation && @authenticated
+      def update_master_password!(new_master_password, new_master_password_confirmation)
+        if new_master_password == new_master_password_confirmation && authenticated?
+          new_master_password_salt = rbnacl_random_bytes
+          new_master_password_hash = rbnacl_scrypt_hash(new_master_password, new_master_password_salt)
+          vault_key = rbnacl_random_bytes
+          vault = rbnacl_box(new_master_password_hash)
+          encrypted_vault_key = vault.encrypt(vault_key)
 
-        new_master_pw_info = generate_master_pw_hash(new_master_pw)
-        new_master_pw_hash = new_master_pw_info[:master_pw_hash]
-        new_master_pw_salt = new_master_pw_info[:salt]
+          new_password_data = @stored_passwords.map do |stored_password|
+            info = {}
+            info['website_title'] = stored_password[:website_title]
+            info['username'] = retrieve_password_info(stored_password[:dir_name], 'username')
+            info['password'] = retrieve_password_info(stored_password[:dir_name], 'password')
+            info
+          end
 
-        @stored_passwords.each do |stored_password|
-          pw_info = get_pw_file(stored_password)
-          pw = decrypt_pw(pw_info['iv'], pw_info['password'], @master_pw, @master_pw_salt)
-          pw_info_for_file = make_pw_info(pw_info['username'], pw, new_master_pw, new_master_pw_salt)
-          write_pw_to_file(stored_password, **pw_info_for_file)
+          FileUtils.copy_entry(pwmanager_dir, pwmanager_tmp_dir)
+          FileUtils.remove_entry_secure(pwmanager_dir)
+          @vault = rbnacl_box(vault_key)
+          make_pwmanager_dir
+          new_password_data.each do |new_password|
+            website_title = new_password['website_title']
+            username = new_password['username']
+            password = new_password['password']
+            save_password(website_title, username, password, password)
+          end
+          FileUtils.remove_entry_secure(pwmanager_tmp_dir)
+          write_master_info(new_master_password_salt, encrypted_vault_key)
+          @master_password_salt = master_password_salt
+          @master_encrypted_vault_key = encrypted_vault_key
+          true
+        else
+          false
+        end
+      end
+
+      def authenticated?
+        @authenticated
+      end
+
+      def update_stored_passwords!
+        @stored_passwords = get_stored_pws.map do |stored_password|
+          {
+            'dir_name': stored_password,
+            'website_title': decode_encrypted_utf8_string(stored_password),
+            'username': retrieve_password_info(stored_password, 'username')
+          }
         end
+      end
+
+      private
+
+      def rbnacl_box(key)
+        RbNaCl::SimpleBox.from_secret_key(key)
+      end
+
+      def rbnacl_random_bytes
+        RbNaCl::Random.random_bytes(RbNaCl::PasswordHash::SCrypt::SALTBYTES)
+      end
+
+      def rbnacl_scrypt_hash(password, salt)
+        RbNaCl::PasswordHash.scrypt(password, salt, OPSLIMIT, MEMLIMIT, DIGEST_SIZE)
+      end
+
+      def decode_encrypted_utf8_string(encrypted_string)
+        decoded_data = Base64.urlsafe_decode64(encrypted_string)
+        @vault.decrypt(decoded_data)
+      end
 
-        write_pw_to_file('master', password: new_master_pw_hash, salt: new_master_pw_salt)
-        @master_pw_hash = get_master_pw_info
-        @master_pw = new_master_pw
-        @master_pw_salt = new_master_pw_salt
-        true
+      def write_master_info(master_password_salt, master_vault_key)
+        write_to_file(password_file('master_password_salt'), master_password_salt, true)
+        write_to_file(password_file('master_encrypted_vault_key'), master_vault_key, true)
       end
     end
   end
-end
+end

data/lib/base/editor/password_object_editor.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'base/password_object'
+require 'file_utils/adamantite_file_utils'
+require 'pw_utils/pw_utils'
+
+module Adamantite
+  module Base
+    module Editor
+      class PasswordObjectEditor
+        include AdamantiteFileUtils
+        include PWUtils
+
+        # editable_user provides the temporary user object for editing
+        attr_reader :editable_password_object
+
+        # initializes a user editor with nil when creating a new user
+        # or with an existing user when editing an existing user
+        def initialize(adamantite, password_object = nil)
+          @password_object = password_object || PasswordObject.new
+          @adamantite = adamantite
+          reset_editable_password_object
+        end
+
+        def reset_editable_password_object
+          @editable_password_object = PasswordObject.new
+          @editable_password_object.website_title = @password_object.website_title
+          @editable_password_object.username = @password_object.username
+          @editable_password_object.password = @password_object.password
+          @editable_password_object.password_confirmation = @password_object.password_confirmation
+        end
+
+        # saves editable user data and returns final user to add to DB/File/Array/etc...
+        def save
+          return false unless @password_object.password == @password_object.password_confirmation
+
+          @password_object.website_title = @editable_password_object.website_title
+          @password_object.username = @editable_password_object.username
+          @password_object.password = @editable_password_object.password
+          @password_object.password_confirmation = @editable_password_object.password_confirmation
+          @password_object.dir_name = @adamantite.save_password(@password_object.website_title,
+                                                                @password_object.username,
+                                                                @password_object.password,
+                                                                @password_object.password_confirmation)
+
+          @adamantite.delete_password(@password_object.initial_dir_name) if @password_object.initial_dir_name
+          @password_object
+        end
+
+        def cancel
+          reset_editable_password_object
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/base/password_object.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Adamantite
+  module Base
+    class PasswordObject
+      attr_accessor :website_title, :username, :password, :password_confirmation,
+                    :row_index, :dir_name, :initial_dir_name
+
+      def initialize(website_title = nil, username = nil, password = nil,
+                     password_confirmation = nil, row_index = nil, initial_dir_name = nil)
+        @website_title = website_title
+        @username = username
+        @password = password
+        @password_confirmation = password_confirmation
+        @row_index = row_index
+        @initial_dir_name = initial_dir_name
+      end
+    end
+  end
+end

data/lib/file_utils/adamantite_file_utils.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Adamantite
+  module AdamantiteFileUtils
+    def home_dir
+      ENV['HOME']
+    end
+
+    def pwmanager_dir
+      File.join(home_dir, '.adamantite')
+    end
+
+    def pwmanager_tmp_dir
+      File.join(home_dir, '.adamantite_tmp')
+    end
+
+    def pwmanager_dir_exists?
+      Dir.exist?(pwmanager_dir)
+    end
+
+    def make_pwmanager_dir
+      Dir.mkdir(pwmanager_dir)
+    end
+
+    def make_password_dir(password_dir_title)
+      Dir.mkdir(File.join(pwmanager_dir, password_dir_title))
+    end
+
+    def pw_file(title)
+      File.join(pwmanager_dir, title)
+    end
+
+    def password_file(*args)
+      File.join(pwmanager_dir, *args)
+    end
+
+    def pw_file_exists?(title)
+      File.exist?(pw_file(title))
+    end
+
+    def write_pw_to_file(title, **kwargs)
+      make_pwmanager_dir unless pwmanager_dir_exists?
+
+      File.open(pw_file(title), 'w') do |f|
+        JSON.dump(kwargs, f)
+      end
+    end
+
+    def write_to_file(file_name, file_contents, binary)
+      if binary
+        File.open(file_name, 'wb') do |f|
+          f.write(file_contents)
+        end
+      else
+        File.open(file_name, 'w') do |f|
+          f.write(file_contents)
+        end
+      end
+    end
+
+    def read_file(file_name, binary)
+      if binary
+        File.open(file_name, 'rb', &:read)
+      else
+        File.open(file_name, 'r', &:read)
+      end
+    end
+
+    def delete_pw_file(title)
+      File.delete(pw_file(title))
+    end
+
+    def get_pw_file(title)
+      JSON.load_file(pw_file(title))
+    end
+
+    def get_master_password_info
+      get_pw_file('master')
+    end
+
+    def get_master_password_hash
+      File.open(pw_file('master_password_hash'), 'rb', &:read)
+    end
+
+    def get_master_password_salt
+      File.open(pw_file('master_password_salt'), 'rb', &:read)
+    end
+
+    def get_master_encrypted_vault_key
+      File.open(pw_file('master_encrypted_vault_key'), 'rb', &:read)
+    end
+
+    def get_stored_pws
+      excluded_filenames = ['.', '..', 'master_password_hash', 'master_password_salt', 'master_encrypted_vault_key']
+      Dir.entries(pwmanager_dir).filter { |f| !excluded_filenames.include?(f) }
+    end
+
+    def master_password_exists?
+      pw_file_exists?('master_encrypted_vault_key') && pw_file_exists?('master_password_salt')
+    end
+  end
+end

data/lib/gui/form/password_object_form_window.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'base/editor/password_object_editor'
+
+module Adamantite
+  module GUI
+    module Form
+      class PasswordObjectFormWindow
+        include Glimmer::LibUI::CustomWindow
+
+        # This holds the final user produced by the form
+        # And, a user can be optionally passed (e.g. `user_form(user: someuser)`) when editing an existing user
+        option :password_object, default: nil
+        option :on_save, default: ->(password_object) {}
+        option :adamantite
+
+        before_body do
+          @password_object_editor = Base::Editor::PasswordObjectEditor.new(adamantite, password_object)
+        end
+
+        body do
+          window('Password Form', 50, 50) do |password_object_form_editor|
+            margined true
+
+            vertical_box do
+              form do
+                entry do
+                  label 'Website Title'
+                  text <=> [@password_object_editor.editable_password_object, :website_title]
+                end
+                entry do
+                  label 'Username'
+                  text <=> [@password_object_editor.editable_password_object, :username]
+                end
+
+                password_entry do
+                  label 'Password'
+                  text <=> [@password_object_editor.editable_password_object, :password]
+                end
+                password_entry do
+                  label 'Password Confirmation'
+                  text <=> [@password_object_editor.editable_password_object, :password_confirmation]
+                end
+              end
+
+              horizontal_box do
+                stretchy false
+
+                button('Save') do
+                  on_clicked do
+                    self.password_object = @password_object_editor.save
+                    on_save.call(password_object)
+                    password_object_form_editor.destroy
+                  end
+                end
+
+                button('Cancel') do
+                  on_clicked do
+                    @password_object_editor.cancel
+                    password_object_form_editor.destroy
+                  end
+                end
+              end
+            end
+
+            on_closing do
+              @password_object_editor.cancel
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gui/request/add_password_request.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module Adamantite
   module GUI
     module Request
       class AddPasswordRequest
-
         attr_accessor :website_title, :username, :password, :password_confirmation, :password_saved
 
         def initialize(master_password, master_password_salt)
@@ -12,13 +13,13 @@ module Adamantite
         end
 
         def confirm_and_add_password!
-          if @password == @password_confirmation
-            @password_saved = true
-            pw_info_for_file = make_pw_info(@username, @password, @master_password, @master_password_salt)
-            write_pw_to_file(@website_title, **pw_info_for_file)
-          end
+          return unless @password == @password_confirmation
+
+          @password_saved = true
+          pw_info_for_file = make_pw_info(@username, @password, @master_password, @master_password_salt)
+          write_pw_to_file(@website_title, **pw_info_for_file)
         end
       end
     end
   end
-end
+end

data/lib/gui/request/login_request.rb

@@ -1,23 +1,19 @@
+# frozen_string_literal: true
+
+require 'base/adamantite'
+
 module Adamantite
   module GUI
     module Request
-      class LoginRequest
 
-        attr_accessor :master_password, :master_password_salt, :authenticated
+        attr_accessor :adamantite, :master_password, :authenticated
 
         def authenticate!
-          user_master_pw_info = get_master_pw_info
-          master_pw_hash = user_master_pw_info['password']
-          master_pw_salt = user_master_pw_info['salt']
-          master_pw_comparator = generate_master_pw_comparator(master_pw_hash)
-
-          if master_pw_comparator == master_password + master_pw_salt
-            @authenticated = true
-            @master_password = master_password
-            @master_password_salt = master_pw_salt
-          end
+          @adamantite = Base::Adamantite.new(master_password)
+          @adamantite.authenticate!
+          @authenticated = @adamantite.authenticated?
         end
       end
     end
   end
-end
+end

data/lib/gui/request/set_master_password_request.rb

@@ -1,20 +1,19 @@
+# frozen_string_literal: true
+
+require 'base/adamantite'
+
 module Adamantite
   module GUI
     module Request
       class SetMasterPasswordRequest
-
         attr_accessor :new_master_pw, :new_master_pw_confirmation, :success
 
         def set_master_password!
           @success = false
-          if @new_master_pw == @new_master_pw_confirmation
-            master_pw_info = generate_master_pw_hash(@new_master_pw)
-            write_pw_to_file('master', password: master_pw_info[:master_pw_hash], salt: master_pw_info[:salt])
-            @success = true
-          end
-          @success
+          adamantite = Base::Adamantite.new(@new_master_pw)
+          @success = adamantite.serialize_master_password(@new_master_pw, @new_master_pw_confirmation)
         end
       end
     end
   end
-end
+end

data/lib/gui/request/update_master_password_request.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
+
 module Adamantite
   module GUI
     module Request
       class UpdateMasterPasswordRequest
+        attr_accessor :new_master_pw, :new_master_pw_confirmation, :adamantite
 
-        attr_accessor :new_master_pw, :new_master_pw_confirmation, :adamantite_object
-
-        def initialize(adamantite_object)
-          @adamantite_object = adamantite_object
+        def initialize(adamantite)
+          @adamantite = adamantite
         end
       end
     end
   end
-end
+end

data/lib/gui/screen/copy_screen.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Adamantite
   module GUI
     module Screen
@@ -6,13 +8,13 @@ module Adamantite
 
         option :password_title
 
-        body {
-          window('Copy', 400, 100) {
+        body do
+          window('Adamantite - Copy Password', 400, 100) do
             margined true
             label("Copied password for #{password_title} to your clipboard.")
-          }
-        }
+          end
+        end
       end
     end
   end
-end
+end

data/lib/gui/screen/login_screen.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module PWManager
   module GUI
@@ -7,19 +8,19 @@ module PWManager
 
         option :login_request
 
-        body {
-          window('Adamantite', 400, 100) {
+        body do
+          window('Adamantite - Login', 400, 100) do
             margined true
 
-            vertical_box {
-              form {
-                password_entry {
+            vertical_box do
+              form do
+                password_entry do
                   label 'Master Password'
                   text <=> [login_request, :master_password]
-                }
-              }
+                end
+              end
 
-              button('Login') {
+              button('Login') do
                 on_clicked do
                   login_request.authenticate!
                   # Destroy window if password is correct.
@@ -28,11 +29,11 @@ module PWManager
                     ::LibUI.quit
                   end
                 end
-              }
-            }
-          }
-        }
+              end
+            end
+          end
+        end
       end
     end
   end
-end
+end

data/lib/gui/screen/set_master_password_screen.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Adamantite
   module GUI
     module Screen
@@ -6,21 +8,21 @@ module Adamantite
 
         option :set_master_password_request
 
-        body {
-          window('Adamantite - Create Master Password', 450, 150) {
+        body do
+          window('Adamantite - Create Master Password', 450, 150) do
             margined true
-            vertical_box {
-              form {
-                password_entry {
+            vertical_box do
+              form do
+                password_entry do
                   label 'Master Password'
                   text <=> [set_master_password_request, :new_master_pw]
-                }
-                password_entry {
+                end
+                password_entry do
                   label 'Master Password Confirmation'
                   text <=> [set_master_password_request, :new_master_pw_confirmation]
-                }
-              }
-              button('Set Master Password') {
+                end
+              end
+              button('Set Master Password') do
                 on_clicked do
                   set_master_password_request.set_master_password!
                   if set_master_password_request.success
@@ -31,11 +33,11 @@ module Adamantite
                     set_master_password_request.new_master_pw_confirmation = ''
                   end
                 end
-              }
-            }
-          }
-        }
+              end
+            end
+          end
+        end
       end
     end
   end
-end
+end

data/lib/gui/screen/show_screen.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Adamantite
   module GUI
     module Screen
@@ -6,14 +8,14 @@ module Adamantite
 
         option :password
 
-        body {
-          window('Show', 400, 100) {
+        body do
+          window('Adamantite - Show Password', 400, 100) do
             margined true
 
-            label("#{password}")
-          }
-        }
+            label(password.to_s)
+          end
+        end
       end
     end
   end
-end
+end

data/lib/gui/screen/update_master_password_screen.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Adamantite
   module GUI
     module Screen
@@ -6,26 +8,27 @@ module Adamantite
 
         option :update_master_password_request
 
-        body {
-          window('Adamantite - Update Master Password', 450, 150) {
+        body do
+          window('Adamantite - Update Master Password', 450, 150) do
             margined true
-            vertical_box {
-              form {
-                password_entry {
+            vertical_box do
+              form do
+                password_entry do
                   label 'New Master Password'
                   text <=> [update_master_password_request, :new_master_pw]
-                }
-                password_entry {
+                end
+                password_entry do
                   label 'New Master Password Confirmation'
                   text <=> [update_master_password_request, :new_master_pw_confirmation]
-                }
-              }
-              button('Update') {
+                end
+              end
+              button('Update') do
                 on_clicked do
                   new_master_pw = update_master_password_request.new_master_pw
                   new_master_pw_confirmation = update_master_password_request.new_master_pw_confirmation
-                  success = update_master_password_request.adamantite_object.update_master_password!(new_master_pw, new_master_pw_confirmation)
-                  if success
+                  pass = update_master_password_request.adamantite.update_master_password!(new_master_pw,
+                                                                                           new_master_pw_confirmation)
+                  if pass
                     body_root.destroy
                     ::LibUI.quit
                   else
@@ -33,10 +36,10 @@ module Adamantite
                     update_master_password_request.new_master_pw_confirmation = ''
                   end
                 end
-              }
-            }
-          }
-        }
+              end
+            end
+          end
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adamantite
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.5
 platform: ruby
 authors:
 - Jake Bruemmer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-09 00:00:00.000000000 Z
+date: 2023-11-24 00:00:00.000000000 Z
 dependencies: []
 description: A local password manager written in Ruby.
 email: jakebruemmer@gmail.com
@@ -19,9 +19,11 @@ extra_rdoc_files: []
 files:
 - bin/adamantite
 - lib/adamantite.rb
-- lib/adamantite_command_line.rb
 - lib/base/adamantite.rb
-- lib/file_utils/file_utils.rb
+- lib/base/editor/password_object_editor.rb
+- lib/base/password_object.rb
+- lib/file_utils/adamantite_file_utils.rb
+- lib/gui/form/password_object_form_window.rb
 - lib/gui/request/add_password_request.rb
 - lib/gui/request/login_request.rb
 - lib/gui/request/set_master_password_request.rb
@@ -31,7 +33,6 @@ files:
 - lib/gui/screen/set_master_password_screen.rb
 - lib/gui/screen/show_screen.rb
 - lib/gui/screen/update_master_password_screen.rb
-- lib/pw_utils/pw_utils.rb
 homepage: https://github.com/jakebruemmer/adamantite
 licenses:
 - MIT
@@ -44,7 +45,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/adamantite_command_line.rb

@@ -1,95 +0,0 @@
-require "bcrypt"
-require "openssl"
-require "base64"
-require "json"
-require "io/console"
-
-require "file_utils/file_utils"
-require "pw_utils/pw_utils"
-
-include Adamantite::FileUtils
-include Adamantite::PWUtils
-
-puts "Welcome to Adamantite."
-
-if pw_file_exists?('master')
-  user_master_pw_info = get_master_pw_info
-  master_pw_hash = user_master_pw_info['password']
-  master_pw_salt = user_master_pw_info['salt']
-
-  master_pw = IO::console.getpass("Please enter your master password:")
-  master_pw_comparator = BCrypt::Password.new(master_pw_hash)
-
-  while master_pw_comparator != master_pw + master_pw_salt
-    puts "Entered password didn't match."
-    master_pw = IO::console.getpass("Please enter your master password:")
-    master_pw_hash = BCrypt::Password.create(master_pw + user_master_pw_info['salt'])
-  end
-
-  puts "Master password successfully entered."
-  puts "Here are your stored passwords:"
-  get_stored_pws.each_with_index do |pw, index|
-    puts "#{index + 1}. #{pw}"
-  end
-
-  puts "Would you like to enter another password? (Y/N)"
-  response = gets.chomp
-  while !["Y", "N"].include?(response)
-    puts "Please enter Y or N"
-  end
-
-  if response == "Y"
-    puts "What do you want to call this password?"
-    title = gets.chomp
-    puts "What is the username for #{title}?"
-    username = gets.chomp
-    pw = IO::console.getpass("Enter the password for this site.")
-    pw_confirmation = IO::console.getpass("Confirm the password for this site.")
-
-    while pw != pw_confirmation
-      puts "Those didn't match, please enter them again."
-      pw = IO::console.getpass("Enter the password for this site.")
-      pw_confirmation = IO::console.getpass("Confirm the password for this site.")
-    end
-
-    pw_info_for_file = make_pw_info(username, pw, master_pw, master_pw_salt)
-    write_pw_to_file(title, **pw_info_for_file)
-    puts "Successfully stored password for #{title}."
-
-  elsif response == "N"
-    puts "Exiting"
-  end
-
-  puts "Here are your stored passwords:"
-  stored_pws = get_stored_pws
-  stored_pws.each_with_index do |pw, index|
-    puts "#{index + 1}. #{pw}"
-  end
-
-  puts "Enter the number of the password that you would like to retrieve."
-  pw_entry = gets.chomp.to_i
-
-  pw_info = get_pw_file(stored_pws[pw_entry - 1])
-  stored_pw_selection = decrypt_pw(pw_info["iv"], pw_info['password'], master_pw, master_pw_salt)
-
-  IO.popen('pbcopy', 'w') { |f| f << stored_pw_selection }
-
-  puts "Your password has been copied to your clipboard."
-
-else
-  puts "You don't have a master password. Please enter one now."
-  master_pw = IO::console.getpass("Enter your master password:")
-  master_pw_confirmation = IO::console.getpass("Confirm your master password:")
-
-  while master_pw != master_pw_confirmation
-    puts "Those didn't match, please enter them again."
-    master_pw = IO::console.getpass("Enter your master password:")
-    master_pw_confirmation = IO::console.getpass("Confirm your master password:")
-  end
-
-  master_pw_info = generate_master_pw_hash(master_pw)
-
-  write_pw_to_file('master', password: master_pw_info[:master_pw_hash], salt: master_pw_info[:salt])
-
-  puts "Wrote master pw to file."
-end

data/lib/file_utils/file_utils.rb

@@ -1,55 +0,0 @@
-require "json"
-
-module Adamantite
-	module FileUtils
-		def home_dir
-			ENV['HOME']
-		end
-
-		def pwmanager_dir
-			File.join(home_dir, '.pwmanager')
-		end
-
-		def pwmanager_dir_exists?
-			Dir.exists?(pwmanager_dir)
-		end
-
-		def make_pwmanager_dir
-			Dir.mkdir(pwmanager_dir)
-		end
-
-		def pw_file(title)
-			File.join(pwmanager_dir, title)
-		end
-
-		def pw_file_exists?(title)
-			File.exists?(pw_file(title))
-		end
-
-		def write_pw_to_file(title, **kwargs)
-			if !pwmanager_dir_exists?
-				make_pwmanager_dir
-			end
-
-			File.open(pw_file(title), "w") do |f|
-				JSON.dump(kwargs, f)
-			end
-		end
-
-		def delete_pw_file(title)
-			File.delete(pw_file(title))
-		end
-
-		def get_pw_file(title)
-			JSON.load_file(pw_file(title))
-		end
-
-		def get_master_pw_info
-			get_pw_file('master')
-		end
-
-		def get_stored_pws
-			Dir.entries(pwmanager_dir).filter { |f| ![".", "..", "master"].include?(f) }
-		end
-	end
-end

data/lib/pw_utils/pw_utils.rb

@@ -1,40 +0,0 @@
-require "bcrypt"
-require "openssl"
-require "base64"
-
-module Adamantite
-  module PWUtils
-
-    def make_pw_info(username, pw, master_pw, master_pw_salt)
-      cipher = OpenSSL::Cipher::AES256.new(:CBC)
-      cipher.encrypt
-      iv = cipher.random_iv
-      cipher.key = Digest::MD5.hexdigest(master_pw + master_pw_salt)
-      cipher_text = cipher.update(pw) + cipher.final
-      utf8_cipher_text = Base64.encode64(cipher_text).encode('utf-8')
-      utf8_iv = Base64.encode64(iv).encode('utf-8')
-
-      {username: username, password: utf8_cipher_text, iv: utf8_iv}
-    end
-
-    def decrypt_pw(iv, pw_hash, master_pw, master_pw_salt)
-      decrypt_cipher = OpenSSL::Cipher::AES256.new(:CBC)
-      decrypt_cipher.decrypt
-      iv = Base64.decode64(iv.encode('ascii-8bit'))
-      decrypt_cipher.iv = iv
-      decrypt_cipher.key = Digest::MD5.hexdigest(master_pw + master_pw_salt)
-      decrypt_text = Base64.decode64(pw_hash.encode('ascii-8bit'))
-      decrypt_cipher.update(decrypt_text) + decrypt_cipher.final
-    end
-
-    def generate_master_pw_hash(master_pw)
-      salt = BCrypt::Engine.generate_salt
-      master_pw_hash = BCrypt::Password.create(master_pw + salt)
-      {'salt': salt, 'master_pw_hash': master_pw_hash}
-    end
-
-    def generate_master_pw_comparator(master_pw_hash)
-      BCrypt::Password.new(master_pw_hash)
-    end
-  end
-end