pwn 0.5.783 → 0.5.785

data/spec/lib/pwn/plugins/repl/vault_yubikey_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+require 'stringio'
+
+RSpec.describe PWN::Plugins::REPL::Vault, 'hardware pwn-vault command' do
+  around do |example|
+    Dir.mktmpdir('repl-vault-yubikey-') do |root|
+      @root = root
+      example.run
+    end
+  end
+
+  before do
+    allow(Dir).to receive(:home).and_return(@root)
+    stub_const('PWN::Plugins::YubiKey', double('synthetic YubiKey'))
+    allow(PWN::Plugins::YubiKey).to receive(:challenge_response) do |opts|
+      OpenSSL::HMAC.digest('SHA1', 'synthetic-slot-secret', opts[:challenge])
+    end
+    @path = File.join(@root, 'selected-vault')
+    original = { ai: { active: 'ollama', ollama: { model: 'fixture-model' } } }
+    File.binwrite(@path, PWN::Plugins::Vault.encrypt_data(data: YAML.dump(original), yubikey: { slot: 2 }))
+    stub_const('PWN::Env', { driver_opts: { pwn_env_path: @path } })
+    described_class.add_commands
+    @command = Pry::Commands.find_command('pwn-vault').new(pry_instance: Pry.new, output: StringIO.new)
+  end
+
+  it 'edits and refreshes a hardware vault without requiring a sidecar or passing software keys' do
+    expect(PWN::Plugins::Vault).to receive(:edit).with({ file: @path, yubikey: { slot: 2 } }) do |opts|
+      PWN::Plugins::Vault.update(opts) { |cfg| cfg[:ai][:ollama][:model] = 'new-model' }
+    end
+    expect(PWN::Config).to receive(:refresh_env).with({ pwn_env_path: @path, pwn_dec_path: "#{@path}.decryptor", yubikey: { slot: 2 } })
+    @command.process
+    expect(PWN::Plugins::Vault.dump(file: @path).dig(:ai, :ollama, :model)).to eq('new-model')
+    expect(PWN::Plugins::Vault.hardware_encrypted?(file: @path)).to be(true)
+    expect(Dir.children(@root)).to eq(['selected-vault'])
+  end
+end

data/spec/lib/pwn/plugins/repl_spec.rb

@@ -17,7 +17,14 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
       File.write("#{path}.decryptor", YAML.dump(key: key, iv: iv))
       PWN::Plugins::Vault.encrypt(file: path, key: key, iv: iv)
       PWN::Env[:driver_opts] = { pwn_env_path: path, pwn_dec_path: "#{path}.decryptor" }
+      expect(PWN::Plugins::Vault).not_to receive(:decrypt)
+      allow(File).to receive(:write).and_wrap_original do |method, target, bytes, *args|
+        expect(bytes.to_s).not_to include('new role')
+        method.call(target, bytes, *args)
+      end
       expect(described_class.pwn_ai_apply_system_role(engine: 'openai', content: "new role\nsecond line")).to eq(:saved)
+      RSpec::Mocks.space.proxy_for(PWN::Plugins::Vault).reset
+      RSpec::Mocks.space.proxy_for(File).reset
       expect(PWN::Env.dig(:ai, :openai, :system_role_content)).to eq("new role\nsecond line")
       expect(File.read(path)).not_to include('new role')
       PWN::Plugins::Vault.decrypt(file: path, key: key, iv: iv)
@@ -42,7 +49,11 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
       PWN::Plugins::Vault.encrypt(file: path, key: key, iv: iv)
       ciphertext = File.binread(path)
       PWN::Env[:driver_opts] = { pwn_env_path: path, pwn_dec_path: "#{path}.decryptor" }
-      allow(PWN::Plugins::Vault).to receive(:encrypt).and_raise(IOError, 'fixture encryption failure')
+      allow(OpenSSL::Cipher).to receive(:new).and_wrap_original do |method, *args|
+        cipher = method.call(*args)
+        allow(cipher).to receive(:encrypt).and_raise(IOError, 'fixture encryption failure')
+        cipher
+      end
       expect { described_class.pwn_ai_apply_system_role(engine: 'openai', content: 'unsaved') }.to raise_error(/not saved/)
       expect(PWN::Env.dig(:ai, :openai, :system_role_content)).to eq('original')
       expect(File.binread(path)).to eq(ciphertext)
@@ -51,6 +62,47 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
       PWN::Env[:driver_opts] = previous_driver_opts
     end
 
+    it 'leaves no plaintext staging bytes when killed at encryption startup' do
+      previous_driver_opts = PWN::Env[:driver_opts]
+      path = File.join(@tmp, 'kill-model.yaml')
+      key = Base64.strict_encode64('k' * 32)
+      iv = Base64.strict_encode64('i' * 16)
+      File.write(path, YAML.dump(ai: { active: 'openai' }, fixture: 'PRIVATE_FIXTURE_SENTINEL'))
+      File.write("#{path}.decryptor", YAML.dump(key: key, iv: iv))
+      PWN::Plugins::Vault.encrypt(file: path, key: key, iv: iv)
+      ciphertext = File.binread(path)
+      PWN::Env[:driver_opts] = { pwn_env_path: path }
+      reader, writer = IO.pipe
+      pid = fork do
+        reader.close
+        allow(OpenSSL::Cipher).to receive(:new).and_wrap_original do |method, *args|
+          cipher = method.call(*args)
+          allow(cipher).to receive(:encrypt) do
+            writer.write('ready')
+            sleep 60
+          end
+          cipher
+        end
+        described_class.persist_ai_selection(engine: 'openai', model: 'offline')
+        exit! 1
+      end
+      writer.close
+      Timeout.timeout(5) { expect(reader.read(5)).to eq('ready') }
+      Process.kill('KILL', pid)
+      Process.wait(pid)
+      pid = nil
+      expect(File.binread(path)).to eq(ciphertext)
+      # Shared Vault.update encrypts before allocating a ciphertext-only stage.
+      stages = Dir.glob(File.join(@tmp, '{.pwn-ai-selection*,.pwn-vault-*}'))
+      expect(stages).to be_empty
+    ensure
+      Process.kill('KILL', pid) if pid
+      Process.wait(pid) if pid
+      reader&.close
+      writer&.close unless writer&.closed?
+      PWN::Env[:driver_opts] = previous_driver_opts
+    end
+
     it 'rejects role saves without a decryptor or after switching the active engine' do
       previous_driver_opts = PWN::Env[:driver_opts]
       PWN::Env[:driver_opts] = { pwn_env_path: File.join(@tmp, 'missing.yaml'), pwn_dec_path: File.join(@tmp, 'missing.decryptor') }
@@ -783,15 +835,14 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
         yaml = File.join(dir, 'pwn.yaml')
         dec = "#{yaml}.decryptor"
         File.write(yaml, YAML.dump({ plugins: { meshtastic: { transport: 'mqtt', channel: { active: 'LongFast' } } } }))
-        File.write(dec, YAML.dump({ key: 'k' * 32, iv: 'i' * 16 }))
-        allow(PWN::Plugins::Vault).to receive(:decrypt)
-        allow(PWN::Plugins::Vault).to receive(:encrypt)
+        PWN::Plugins::Vault.create(file: yaml, decryptor_file: dec)
+        credentials = YAML.safe_load_file(dec, symbolize_names: true)
         prev = PWN::Env[:driver_opts]
         PWN::Env[:driver_opts] = { pwn_env_path: yaml, pwn_dec_path: dec }
         described_class.persist_mesh_env(
           mesh: { transport: 'serial', channel: { active: 'LongFast' }, serial: { port: '/dev/ttyACM0' } }
         )
-        cfg = YAML.load_file(yaml, symbolize_names: true)
+        cfg = PWN::Plugins::Vault.dump({ file: yaml }.merge(credentials))
         expect(cfg.dig(:plugins, :meshtastic, :transport).to_s).to eq('serial')
         expect(cfg.dig(:plugins, :meshtastic, :channel, :active).to_s).to eq('LongFast')
         expect(cfg.dig(:plugins, :meshtastic, :serial, :port)).to eq('/dev/ttyACM0')

data/spec/lib/pwn/plugins/transparent_browser_jev_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe PWN::Plugins::TransparentBrowser, 'jev action loop' do
+  let(:browser) { double('browser', goto: nil) }
+  let(:browser_obj) { { type: :headless, browser: browser } }
+
+  before do
+    Thread.current[:pwn_jev_model] = nil
+    allow(PWN::Env).to receive(:dig).and_call_original
+    allow(PWN::Env).to receive(:dig).with(:ai, :openwebui).and_return({ base_uri: 'https://ow.example', key: 'token', model: 'llama' })
+    allow(PWN::Env).to receive(:dig).with(:ai, :active).and_return(:grok)
+    allow(PWN::Env).to receive(:dig).with(:ai, :grok, :model).and_return('grok-4')
+    allow(PWN::AI::OpenWebUI).to receive(:get_models).and_return([{ id: 'jev-27b' }])
+  end
+
+  after { Thread.current[:pwn_jev_model] = nil }
+
+  it 'stays inactive when Open WebUI has no Jev model' do
+    allow(PWN::AI::OpenWebUI).to receive(:get_models).and_return([{ id: 'llama' }])
+    expect(described_class.act(browser_obj: browser_obj, goal: 'find the article')).to include(available: false, status: 'unavailable')
+  end
+
+  it 'asks Jev for the operation and the active engine only for typed text' do
+    scripts = []
+    allow(browser).to receive(:execute_script) do |script|
+      if script.include?('querySelectorAll')
+        { 'url' => 'https://example.test', 'title' => 'Example', 'rows' => [{ 'index' => 1, 'role' => 'textbox', 'name' => 'Where to?', 'value' => '' }] }
+      else
+        scripts << script
+        { 'status' => scripts.length == 1 ? 'acted' : 'done' }
+      end
+    end
+    decisions = ['{"operation":"TYPE_TEXT","target":1}', '{"operation":"DONE","target":0}']
+    allow(PWN::AI::OpenWebUI).to receive(:chat) { { choices: [{ role: 'assistant', content: decisions.shift }] } }
+    allow(PWN::AI::Grok).to receive(:chat).and_return({ choices: [{ role: 'assistant', content: '{"text":"London"}' }] })
+
+    result = described_class.act(browser_obj: browser_obj, goal: 'Search for London', steps: 2)
+
+    expect(result).to include(available: true, status: 'done', jev_model: 'jev-27b', text_engine: :grok, text_model: 'grok-4')
+    expect(PWN::AI::Grok).to have_received(:chat)
+    expect(scripts.first).to include('London')
+    expect(scripts.first).not_to include('querySelectorAll')
+  end
+end

data/spec/lib/pwn/plugins/vault_native_yubikey_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe PWN::Plugins::Vault, 'native YubiKey selectors' do
+  before do
+    @device = double('offline native YubiKey')
+    stub_const('PWN::Plugins::YubiKey', @device)
+    allow(@device).to receive(:challenge_response) { |opts| OpenSSL::HMAC.digest('SHA1', 'fixture-slot', opts[:challenge]) }
+  end
+
+  it 'forwards caller-owned native controls unchanged and persists only public slot and serial selectors' do
+    connection = double('native connection', exchange: ''.b)
+    selector = { slot: 1, serial: '001234', device_path: '/fixture/native-device', connection: connection, timeout: 1.5 }.freeze
+    expect(@device).to receive(:challenge_response).with(hash_including(selector)).twice
+    envelope = described_class.seal_credentials(credentials: { token: 'fixture' }, yubikey: selector)
+    expect(envelope.fetch('yubikey').keys).to contain_exactly('slot', 'serial', 'challenge')
+    expect(envelope.fetch('yubikey')).to include('slot' => 1, 'serial' => '001234')
+    expect(described_class.open_credentials(envelope: envelope, yubikey: selector)).to eq('token' => 'fixture')
+  end
+
+  it 'accepts an exact caller-owned smartcard reader without serial and never persists it' do
+    selector = { slot: 2, reader: ' Fixture NFC reader ' }.freeze
+    expect(@device).to receive(:challenge_response).with(hash_including(selector)).twice
+    envelope = described_class.seal_credentials(credentials: {}, yubikey: selector)
+    expect(envelope.fetch('yubikey').keys).to contain_exactly('slot', 'challenge')
+    expect(described_class.open_credentials(envelope: envelope, yubikey: selector)).to eq({})
+  end
+end

data/spec/lib/pwn/plugins/vault_publication_safety_spec.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+require 'timeout'
+
+RSpec.describe PWN::Plugins::Vault, 'serialized publication safety' do
+  before do
+    @root = Dir.mktmpdir('vault-publication-safety-')
+    allow(Dir).to receive(:home).and_return(@root)
+    @device = double('offline YubiKey')
+    stub_const('PWN::Plugins::YubiKey', @device)
+    allow(@device).to receive(:challenge_response) { |opts| OpenSSL::HMAC.digest('SHA1', 'fixture-slot', opts[:challenge]) }
+    @path = File.join(@root, 'vault')
+    @legacy = { key: Base64.strict_encode64('k' * 32), iv: Base64.strict_encode64('i' * 16) }
+    @document = { token: 'fixture', retained: 'original' }
+    @threads = []
+  end
+
+  after do
+    @threads.each do |thread|
+      thread.kill if thread.alive?
+      thread.join(1)
+    end
+    FileUtils.remove_entry(@root)
+  end
+
+  def writer_thread(role, &block)
+    thread = Thread.new do
+      Thread.current.report_on_exception = false
+      Thread.current[:vault_publication_role] = role
+      block.call
+    end
+    @threads << thread
+    thread
+  end
+
+  def prepare_vault(backend = :hardware)
+    access = backend == :hardware ? { yubikey: {} } : @legacy
+    File.binwrite(@path, described_class.encrypt_data(access.merge(data: YAML.dump(@document))))
+  end
+
+  def fake_editor
+    allow(File).to receive(:executable?).and_call_original
+    allow(File).to receive(:executable?).with('/offline-editor').and_return(true)
+    allow(described_class).to receive(:system).with('/offline-editor', anything) do |_editor, path|
+      File.write(path, YAML.dump(@document.merge(edited: true)))
+      true
+    end
+  end
+
+  %i[refresh_encryption_secrets edit].each do |writer|
+    it "serializes #{writer} against update even when paused after its baseline check", :aggregate_failures do
+      prepare_vault
+      fake_editor if writer == :edit
+      ready = Queue.new
+      release = Queue.new
+      attempts = Queue.new
+      allow(File).to receive(:rename).and_wrap_original do |rename, from, to|
+        if to == @path && Thread.current[:vault_publication_role] == :first
+          ready << true
+          release.pop
+        end
+        rename.call(from, to)
+      end
+      # Probe the updater's actual flock before blocking. This makes the old
+      # unchecked-rename interleaving deterministic, without sleeps or polling.
+      allow(File).to receive(:open).and_wrap_original do |open, *args, **kwargs, &block|
+        if args == [@root, File::RDONLY] && Thread.current[:vault_publication_role] == :updater
+          open.call(*args) do |lock|
+            allow(lock).to receive(:flock).and_wrap_original do |flock, operation|
+              if operation == File::LOCK_EX
+                acquired = flock.call(operation | File::LOCK_NB)
+                attempts << (acquired ? :acquired : :blocked)
+                acquired || flock.call(operation)
+              else
+                flock.call(operation)
+              end
+            end
+            block.call(lock)
+          end
+        else
+          open.call(*args, **kwargs, &block)
+        end
+      end
+      attempt = nil
+      Timeout.timeout(5) do
+        first = writer_thread(:first) { described_class.public_send(writer, file: @path, editor: '/offline-editor') }
+        ready.pop
+        updater = writer_thread(:updater) { described_class.update(file: @path) { |cfg| cfg[:updated] = true } }
+        attempt = attempts.pop
+        updater.value if attempt == :acquired
+        release << true
+        first.value
+        expect(updater.value).to eq(:saved)
+      end
+      expect(attempt).to eq(:blocked)
+      expected = @document.merge(updated: true)
+      expected[:edited] = true if writer == :edit
+      expect(described_class.dump(file: @path)).to eq(expected)
+      expect(Dir.glob(File.join(@root, '.pwn-vault-*'))).to be_empty
+    end
+  end
+
+  %i[update refresh_encryption_secrets edit encrypt decrypt create legacy_refresh legacy_create].each do |writer|
+    it "holds the shared directory lock through every #{writer} rename" do
+      if %i[encrypt create legacy_create].include?(writer)
+        File.write(@path, YAML.dump(@document))
+      else
+        prepare_vault(writer == :legacy_refresh ? :legacy : :hardware)
+      end
+      fake_editor if writer == :edit
+      publications = 0
+      allow(File).to receive(:rename).and_wrap_original do |rename, from, to|
+        if to == @path
+          File.open(@root, File::RDONLY) do |probe|
+            expect(probe.flock(File::LOCK_EX | File::LOCK_NB)).to be(false)
+          end
+          publications += 1
+        end
+        rename.call(from, to)
+      end
+      Timeout.timeout(5) do
+        case writer
+        when :update
+          described_class.update(file: @path) { |cfg| cfg[:updated] = true }
+        when :legacy_refresh
+          described_class.refresh_encryption_secrets(@legacy.merge(file: @path))
+        when :legacy_create
+          described_class.create(file: @path, decryptor_file: "#{@path}.decryptor")
+        when :create, :encrypt
+          described_class.public_send(writer, file: @path, yubikey: {})
+        else
+          described_class.public_send(writer, file: @path, editor: '/offline-editor')
+        end
+      end
+      expect(publications).to be_positive
+    end
+  end
+
+  it 'allows nested updates in one directory without reacquiring its own lock' do
+    prepare_vault
+    sibling = File.join(@root, 'sibling')
+    File.binwrite(sibling, File.binread(@path))
+    Timeout.timeout(5) do
+      described_class.update(file: @path) do |cfg|
+        described_class.update(file: sibling) { |other| other[:nested] = true }
+        cfg[:outer] = true
+      end
+    end
+    expect(described_class.dump(file: @path)).to eq(@document.merge(outer: true))
+    expect(described_class.dump(file: sibling)).to eq(@document.merge(nested: true))
+  end
+
+  it 'retains expected-byte conflict detection for nested writes to the same vault' do
+    prepare_vault
+    Timeout.timeout(5) do
+      expect do
+        described_class.update(file: @path) do |cfg|
+          described_class.refresh_encryption_secrets(file: @path)
+          cfg[:stale] = true
+        end
+      end.to raise_error(IOError, /changed before replacement/)
+    end
+    expect(described_class.dump(file: @path)).to eq(@document)
+  end
+
+  it 'does not overwrite changes from a writer that bypasses the advisory lock' do
+    prepare_vault
+    replacement = described_class.encrypt_data(data: YAML.dump(@document.merge(external: true)), yubikey: {})
+    expect do
+      described_class.update(file: @path) do |cfg|
+        File.binwrite(@path, replacement)
+        cfg[:stale] = true
+      end
+    end.to raise_error(IOError, /changed before replacement/)
+    expect(File.binread(@path)).to eq(replacement)
+    expect(Dir.children(@root)).to eq(['vault'])
+  end
+
+  it 'recognizes directory aliases when reentering its own publication lock' do
+    prepare_vault
+    sibling = File.join(@root, 'sibling')
+    File.binwrite(sibling, File.binread(@path))
+    File.symlink(@root, File.join(@root, 'alias'))
+    Timeout.timeout(5) do
+      described_class.update(file: @path) do |cfg|
+        described_class.update(file: File.join(@root, 'alias', 'sibling')) { |other| other[:aliased] = true }
+        cfg[:outer] = true
+      end
+    end
+    expect(described_class.dump(file: sibling)).to eq(@document.merge(aliased: true))
+    expect(described_class.dump(file: @path)).to eq(@document.merge(outer: true))
+  end
+
+  it 'does not treat a lock inherited across fork as owned by the child' do
+    prepare_vault
+    reader, writer = IO.pipe
+    pid = nil
+    Timeout.timeout(8) do
+      described_class.update(file: @path) do |cfg|
+        pid = fork do
+          reader.close
+          allow(File).to receive(:open).and_wrap_original do |open, *args, **kwargs, &block|
+            if args == [@root, File::RDONLY]
+              open.call(*args) do |lock|
+                allow(lock).to receive(:flock).and_wrap_original do |flock, operation|
+                  if operation == File::LOCK_EX
+                    acquired = flock.call(operation | File::LOCK_NB)
+                    writer.puts(acquired ? 'acquired' : 'blocked')
+                    acquired || flock.call(operation)
+                  else
+                    flock.call(operation)
+                  end
+                end
+                block.call(lock)
+              end
+            else
+              open.call(*args, **kwargs, &block)
+            end
+          end
+          begin
+            described_class.update(file: @path) { |child| child[:child] = true }
+            writer.puts('saved')
+            exit! 0
+          rescue StandardError, RSpec::Mocks::MockExpectationError
+            writer.puts('failed')
+            exit! 1
+          end
+        end
+        writer.close
+        expect(reader.gets).to eq("blocked\n")
+        cfg[:parent] = true
+      end
+      expect(reader.gets).to eq("saved\n")
+      _, status = Process.waitpid2(pid)
+      pid = nil
+      expect(status.success?).to be(true)
+    end
+    expect(described_class.dump(file: @path)).to eq(@document.merge(parent: true, child: true))
+  ensure
+    if pid
+      Process.kill('KILL', pid)
+      Process.waitpid(pid)
+    end
+    reader&.close unless reader&.closed?
+    writer&.close unless writer&.closed?
+  end
+
+  it 'preserves original ciphertext and removes staging files when publication fails' do
+    prepare_vault
+    original = File.binread(@path)
+    allow(File).to receive(:rename).and_raise(IOError, 'fixture rename failure')
+    expect { described_class.update(file: @path) { |cfg| cfg[:changed] = true } }.to raise_error(IOError, 'fixture rename failure')
+    expect(File.binread(@path)).to eq(original)
+    expect(Dir.children(@root)).to eq(['vault'])
+  end
+end