putty-key 1.0.0

data/test/ppk_test.rb

@@ -0,0 +1,247 @@
+require 'test_helper'
+require 'pathname'
+
+class PPKTest < Minitest::Test
+  TEST_COMMENT = 'This is a test ppk file'.b
+  TEST_PUBLIC_BLOB = "\x00\x00\x00\x04test\x00\x00\x00\x4AThis is the public blob from a ppk file created for testing purposes only.".b
+  TEST_PRIVATE_BLOB = "\x00\x00\x00\x77This is the private blob from a ppk file created for testing purposes only. It is slightly longer than the public blob.".b
+
+  def test_initialize
+    ppk = PuTTY::Key::PPK.new
+    assert_nil(ppk.algorithm)
+    assert_nil(ppk.comment)
+    assert_nil(ppk.public_blob)
+    assert_nil(ppk.private_blob)
+  end
+
+  def test_initialize_invalid_format
+    [1,3].each do |format|
+      assert_raises(PuTTY::Key::FormatError) { PuTTY::Key::PPK.new(fixture_path("test-invalid-format-#{format}.ppk")) }
+    end
+  end
+
+  def test_initialize_invalid_encryption_type
+    assert_raises(PuTTY::Key::FormatError) { PuTTY::Key::PPK.new(fixture_path('test-invalid-encryption-type.ppk')) }
+  end
+
+  def test_initialize_invalid_private_mac
+    assert_raises(PuTTY::Key::FormatError) { PuTTY::Key::PPK.new(fixture_path('test-invalid-private-mac.ppk')) }
+  end
+
+  def test_initialize_file_not_exists
+    temp_dir do |dir|
+      assert_raises(Errno::ENOENT) { PuTTY::Key::PPK.new(File.join(dir, 'missing')) }
+    end
+  end
+
+  def test_initialize_non_ppk
+    assert_raises(PuTTY::Key::FormatError) { PuTTY::Key::PPK.new(fixture_path('rsa-2048.pem')) }
+  end
+
+  def test_initialize_truncated
+    assert_raises(PuTTY::Key::FormatError) { PuTTY::Key::PPK.new(fixture_path('test-truncated.ppk')) }
+  end
+
+  def test_initialize_invalid_blob_lines
+    assert_raises(PuTTY::Key::FormatError) { PuTTY::Key::PPK.new(fixture_path('test-invalid-blob-lines.ppk')) }
+  end
+
+  def assert_test_ppk_properties(ppk, comment: TEST_COMMENT, encrypted: false)
+    assert_equal(Encoding::ASCII_8BIT, ppk.algorithm.encoding)
+    assert_equal(Encoding::ASCII_8BIT, ppk.comment.encoding)
+    assert_equal(Encoding::ASCII_8BIT, ppk.public_blob.encoding)
+    assert_equal(Encoding::ASCII_8BIT, ppk.private_blob.encoding)
+    assert_equal('test'.b, ppk.algorithm)
+    assert_equal(comment, ppk.comment)
+    assert_equal(TEST_PUBLIC_BLOB, ppk.public_blob)
+
+    if encrypted
+      # When loading an encrypted ppk file, the padding added to the private blob cannot be removed.
+      assert(ppk.private_blob.start_with?(TEST_PRIVATE_BLOB), "Private blob does not start with #{TEST_PRIVATE_BLOB}")
+    else
+      assert_equal(TEST_PRIVATE_BLOB, ppk.private_blob)
+    end
+  end
+
+  def test_initialize_unencrypted
+    ppk = PuTTY::Key::PPK.new(fixture_path('test.ppk'))
+    assert_test_ppk_properties(ppk)
+  end
+
+  def test_initialize_blank_comment
+    ppk = PuTTY::Key::PPK.new(fixture_path('test-blank-comment.ppk'))
+    assert_test_ppk_properties(ppk, comment: ''.b)
+  end
+
+  def test_initialize_encrypted
+    ppk = PuTTY::Key::PPK.new(fixture_path('test-encrypted.ppk'), 'Test Passphrase')
+    assert_test_ppk_properties(ppk, encrypted: true)
+  end
+
+  def test_initialize_encrypted_no_passphrase
+    assert_raises(ArgumentError) { PuTTY::Key::PPK.new(fixture_path('test-encrypted.ppk')) }
+  end
+
+  def test_initialize_encrypted_incorrect_passphrase
+    assert_raises(ArgumentError) { PuTTY::Key::PPK.new(fixture_path('test-encrypted.ppk'), 'Not Test Passphrase') }
+  end
+
+  def test_initialize_pathname
+    ppk = PuTTY::Key::PPK.new(Pathname.new(fixture_path('test.ppk')))
+    assert_test_ppk_properties(ppk)
+  end
+
+  def test_initialize_unix_line_endings
+    ppk = PuTTY::Key::PPK.new(fixture_path('test-unix-line-endings.ppk'))
+    assert_test_ppk_properties(ppk)
+  end
+
+  def create_test_ppk
+    PuTTY::Key::PPK.new.tap do |ppk|
+      ppk.algorithm = 'test'
+      ppk.comment = TEST_COMMENT
+      ppk.public_blob = TEST_PUBLIC_BLOB
+      ppk.private_blob = TEST_PRIVATE_BLOB
+    end
+  end
+
+  def test_save_path_nil
+    ppk = create_test_ppk
+    assert_raises(ArgumentError) { ppk.save(nil) }
+  end
+
+  def test_save_passphrase_encryption_type_nil
+    ppk = create_test_ppk
+    temp_file_name do |file|
+      assert_raises(ArgumentError) { ppk.save(file, 'Test Passphrase', encryption_type: nil) }
+    end
+  end
+
+  def test_save_passphrase_encryption_type_none
+    ppk = create_test_ppk
+    temp_file_name do |file|
+      assert_raises(ArgumentError) { ppk.save(file, 'Test Passphrase', encryption_type: 'none') }
+    end
+  end
+
+  def test_save_passphrase_unsupported_encryption_type
+    ppk = create_test_ppk
+    temp_file_name do |file|
+      assert_raises(ArgumentError) { ppk.save(file, 'Test Passphrase', encryption_type: 'camellia256-cbc') }
+    end
+  end
+
+  def test_save_format_nil
+    ppk = create_test_ppk
+    temp_file_name do |file|
+      assert_raises(ArgumentError) { ppk.save(file, 'Test Passphrase', format: nil) }
+    end
+  end
+
+  def test_save_format_not_supported
+    ppk = create_test_ppk
+    temp_file_name do |file|
+      [1,3].each do |format|
+        assert_raises(ArgumentError) { ppk.save(file, 'Test Passphrase', format: format) }
+      end
+    end
+  end
+
+  def test_save_dir_not_exists
+    ppk = create_test_ppk
+    temp_dir do |dir|
+      assert_raises(Errno::ENOENT) { ppk.save(File.join(dir, 'missing', 'file')) }
+    end
+  end
+
+  def test_save_algorithm_nil
+    ppk = create_test_ppk
+    ppk.algorithm = nil
+    temp_file_name do |file|
+      assert_raises(PuTTY::Key::InvalidStateError) { ppk.save(file) }
+    end
+  end
+
+  def test_save_public_blob_nil
+    ppk = create_test_ppk
+    ppk.public_blob = nil
+    temp_file_name do |file|
+      assert_raises(PuTTY::Key::InvalidStateError) { ppk.save(file) }
+    end
+  end
+
+  def test_save_private_blob_nil
+    ppk = create_test_ppk
+    ppk.private_blob = nil
+    temp_file_name do |file|
+      assert_raises(PuTTY::Key::InvalidStateError) { ppk.save(file) }
+    end
+  end
+
+  def test_save_unencrypted
+    ppk = create_test_ppk
+    temp_file_name do |file|
+      ppk.save(file)
+      assert_identical_to_fixture('test.ppk', file)
+    end
+  end
+
+  def test_save_passphrase_empty
+    ppk = create_test_ppk
+    temp_file_name do |file|
+      ppk.save(file, '')
+      assert_identical_to_fixture('test.ppk', file)
+    end
+  end
+
+  def test_save_encrypted
+    ppk = create_test_ppk
+    temp_file_name do |file|
+      ppk.save(file, 'Test Passphrase')
+      assert_identical_to_fixture('test-encrypted.ppk', file)
+    end
+  end
+
+  def test_save_comment_empty
+    ppk = create_test_ppk
+    ppk.comment = ''
+    temp_file_name do |file|
+      ppk.save(file)
+      assert_identical_to_fixture('test-blank-comment.ppk', file)
+    end
+  end
+
+  def test_save_comment_nil
+    ppk = create_test_ppk
+    ppk.comment = nil
+    temp_file_name do |file|
+      ppk.save(file)
+      assert_identical_to_fixture('test-blank-comment.ppk', file)
+    end
+  end
+
+  def test_save_pathname
+    ppk = create_test_ppk
+    temp_file_name do |file|
+      ppk.save(Pathname.new(file))
+      assert_identical_to_fixture('test.ppk', file)
+    end
+  end
+
+  def test_save_overwrite
+    ppk = create_test_ppk
+    temp_file_name do |file|
+      File.open(file, 'w') { |f| f.write('not test.ppk') }
+      ppk.save(file)
+      assert_identical_to_fixture('test.ppk', file)
+    end
+  end
+
+  def test_save_result
+    ppk = create_test_ppk
+    temp_file_name do |file|
+      result = ppk.save(file)
+      assert_equal(File.size(file), result)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,81 @@
+TEST_TYPE = (ENV['TEST_TYPE'] || 'refinement').to_sym
+raise "Unrecognized TEST_TYPE: #{TEST_TYPE}" unless [:refinement, :global].include?(TEST_TYPE)
+
+TEST_COVERAGE = ENV['TEST_COVERAGE'] != '0'
+
+if TEST_COVERAGE
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.command_name TEST_TYPE.to_s
+
+  SimpleCov.formatters = [
+    SimpleCov::Formatter::HTMLFormatter
+  ]
+
+  SimpleCov.start do
+    add_filter 'test'
+    project_name 'PuTTY::Key'
+  end
+end
+
+require 'putty/key'
+
+require 'fileutils'
+require 'minitest/autorun'
+require 'tmpdir'
+
+PuTTY::Key.global_install if TEST_TYPE == :global
+
+module TestHelper
+  BASE_DIR = File.expand_path(File.dirname(__FILE__))
+
+  module Assertions
+    def assert_files_identical(exp, act, msg = nil)
+      msg = message(msg) { "Expected file #{act} to be identical to #{exp}\n\n#{act}:\n#{File.read(act)}\n\n#{exp}:\n#{File.read(exp)}\n" }
+      assert(FileUtils.identical?(exp, act), msg)
+    end
+
+    def assert_identical_to_fixture(exp_fixture, act_file, msg = nil)
+      assert_files_identical(fixture_path(exp_fixture), act_file, msg)
+    end
+  end
+
+  module Fixtures
+    FIXTURES_DIR = File.join(BASE_DIR, 'fixtures')
+
+    def fixture_path(fixture)
+      File.join(FIXTURES_DIR, fixture)
+    end
+
+    def load_fixture(fixture)
+      File.read(fixture_path(fixture), mode: 'rb')
+    end
+  end
+
+  module Utils
+    def temp_dir(&block)
+      Dir.mktmpdir('putty-key', &block)
+    end
+
+    def temp_file_name(name = nil)
+      temp_dir do |dir|
+        file = File.join(dir, name || 'test')
+        yield file
+      end
+    end
+  end
+
+  class ::OpenSSL::BN
+    # Override to_s so the represented value is visible.
+    def inspect
+      "#<OpenSSL::BN:#{to_s(16)}>"
+    end
+  end
+end
+
+class Minitest::Test
+  include TestHelper::Assertions
+  include TestHelper::Fixtures
+  include TestHelper::Utils
+end

data/test/util_test.rb

@@ -0,0 +1,180 @@
+# encoding: UTF-8
+
+require 'test_helper'
+require 'openssl'
+
+# PuTTY::Key::NilValueError and PuTTY::Key::Util are private constants.
+NilValueError = PuTTY::Key.const_get(:NilValueError)
+Util = PuTTY::Key.const_get(:Util)
+
+class PPKTest < Minitest::Test
+  def test_ssh_pack_empty
+    s = Util.ssh_pack
+    assert_equal(Encoding::ASCII_8BIT, s.encoding)
+    assert_equal("".b, s)
+  end
+
+  def test_ssh_pack_nil_element
+    assert_raises(NilValueError) { Util.ssh_pack('test', nil, 'test2') }
+  end
+
+  def ssh_pack_string_empty
+    s = Util.ssh_pack('')
+    assert_equal(Encoding::ASCII_8BIT, s.encoding)
+    assert_equal("\x00\x00\x00\x00".b, s)
+  end
+
+  def test_ssh_pack_string_utf8
+    s = Util.ssh_pack('This is UTF-8: ✓')
+    assert_equal(Encoding::ASCII_8BIT, s.encoding)
+    assert_equal("\x00\x00\x00\x12This is UTF-8: \xe2\x9c\x93".b, s)
+  end
+
+  def test_ssh_pack_string_binary
+    s = Util.ssh_pack("\x00\x01\x02\x03\x04".b)
+    assert_equal(Encoding::ASCII_8BIT, s.encoding)
+    assert_equal("\x00\x00\x00\x05\x00\x01\x02\x03\x04".b, s)
+  end
+
+  def test_ssh_pack_bn
+    s = Util.ssh_pack(OpenSSL::BN.new(12345678901234567890))
+    assert_equal(Encoding::ASCII_8BIT, s.encoding)
+    assert_equal("\x00\x00\x00\x09\x00\xab\x54\xa9\x8c\xeb\x1f\x0a\xd2".b, s)
+  end
+
+  def test_ssh_pack_bn_postive_msb_unset
+    s = Util.ssh_pack(OpenSSL::BN.new(0x7f), OpenSSL::BN.new(0x7fff))
+    assert_equal(Encoding::ASCII_8BIT, s.encoding)
+    assert_equal("\x00\x00\x00\x01\x7f\x00\x00\x00\x02\x7f\xff".b, s)
+  end
+
+  def test_ssh_pack_bn_postive_msb_set
+    s = Util.ssh_pack(OpenSSL::BN.new(0x80), OpenSSL::BN.new(0xff), OpenSSL::BN.new(0x8000), OpenSSL::BN.new(0xff00))
+    assert_equal(Encoding::ASCII_8BIT, s.encoding)
+    assert_equal("\x00\x00\x00\x02\x00\x80\x00\x00\x00\x02\x00\xff\x00\x00\x00\x03\x00\x80\x00\x00\x00\x00\x03\x00\xff\x00".b, s)
+  end
+
+  def test_ssh_pack_bn_negative
+    s = Util.ssh_pack(OpenSSL::BN.new(-0x01), OpenSSL::BN.new(-0x80), OpenSSL::BN.new(-0x81), OpenSSL::BN.new(-0x0100))
+    assert_equal(Encoding::ASCII_8BIT, s.encoding)
+    assert_equal("\x00\x00\x00\x01\xff\x00\x00\x00\x01\x80\x00\x00\x00\x02\xff\x7f\x00\x00\x00\x02\xff\x00".b, s)
+  end
+
+  def test_ssh_pack_bn_zero
+    s = Util.ssh_pack(OpenSSL::BN.new(0))
+    assert_equal(Encoding::ASCII_8BIT, s.encoding)
+    assert_equal("\x00\x00\x00\x00".b, s)
+  end
+
+  def test_ssh_pack_bn_rfc_4251_mpint_examples
+    s = Util.ssh_pack(OpenSSL::BN.new(0x0), OpenSSL::BN.new(0x9a378f9b2e332a7), OpenSSL::BN.new(0x80), OpenSSL::BN.new(-0x1234), OpenSSL::BN.new(-0xdeadbeef))
+    assert_equal(Encoding::ASCII_8BIT, s.encoding)
+    assert_equal("\x00\x00\x00\x00\x00\x00\x00\x08\x09\xa3\x78\xf9\xb2\xe3\x32\xa7\x00\x00\x00\x02\x00\x80\x00\x00\x00\x02\xed\xcc\x00\x00\x00\x05\xff\x21\x52\x41\x11".b, s)
+  end
+
+  def test_ssh_pack_mixed
+    s = Util.ssh_pack('string1', OpenSSL::BN.new(42), 'string2', OpenSSL::BN.new(1764))
+    assert_equal(Encoding::ASCII_8BIT, s.encoding)
+    assert_equal("\x00\x00\x00\x07string1\x00\x00\x00\x01\x2a\x00\x00\x00\x07string2\x00\x00\x00\x02\x06\xe4".b, s)
+  end
+
+  def test_ssh_unpack_encoded_nil
+    assert_raises(ArgumentError) { Util.ssh_unpack(nil) }
+  end
+
+  def test_ssh_unpack_encoded_not_binary
+    assert_raises(ArgumentError) { Util.ssh_unpack('\x00\x00\x00\x12This is UTF-8: ✓', :string) }
+  end
+
+  def test_ssh_unpack_spec_empty
+    assert_equal([], Util.ssh_unpack("\x00\x00\x00\x06string".b))
+  end
+
+  def test_ssh_unpack_spec_invalid
+    assert_raises(ArgumentError) { Util.ssh_unpack("\x00\x00\x00\x07string1\x00\x00\x00\x07string2\x00\x00\x00\x07string3".b, :string, :unknown, :string) }
+  end
+
+  def test_ssh_unpack_spec_longer_than_encoded
+    assert_raises(PuTTY::Key::FormatError) { Util.ssh_unpack("\x00\x00\x00\x06string".b, :string, :string) }
+  end
+
+  def test_ssh_unpack_encoded_truncated_value
+    assert_raises(PuTTY::Key::FormatError) { Util.ssh_unpack("\x00\x00\x00\x06str".b, :string) }
+  end
+
+  def test_ssh_unpack_encoded_truncated_length
+    assert_raises(PuTTY::Key::FormatError) { Util.ssh_unpack("\x00\x00".b, :string) }
+  end
+
+  def test_ssh_unpack_encoded_missing_value
+    assert_raises(PuTTY::Key::FormatError) { Util.ssh_unpack("\x00\x00\x00\x06".b, :string) }
+  end
+
+  def test_ssh_unpack_string_empty
+    a = Util.ssh_unpack("\x00\x00\x00\x00".b, :string)
+    assert_equal([''.b], a)
+    assert_kind_of(String, a[0])
+    assert_equal(Encoding::ASCII_8BIT, a[0].encoding)
+  end
+
+  def test_ssh_unpack_string_utf8
+    a = Util.ssh_unpack("\x00\x00\x00\x12This is UTF-8: \xe2\x9c\x93".b, :string)
+    assert_equal(["This is UTF-8: \xe2\x9c\x93".b], a)
+    assert_kind_of(String, a[0])
+    assert_equal(Encoding::ASCII_8BIT, a[0].encoding)
+  end
+
+  def test_ssh_unpack_string_binary
+    a = Util.ssh_unpack("\x00\x00\x00\x05\x00\x01\x02\x03\x04".b, :string)
+    assert_equal(["\x00\x01\x02\x03\x04".b], a)
+    assert_kind_of(String, a[0])
+    assert_equal(Encoding::ASCII_8BIT, a[0].encoding)
+  end
+
+  def test_ssh_unpack_bn
+    a = Util.ssh_unpack("\x00\x00\x00\x09\x00\xab\x54\xa9\x8c\xeb\x1f\x0a\xd2".b, :mpint)
+    assert_equal([OpenSSL::BN.new(12345678901234567890)], a)
+    assert_kind_of(OpenSSL::BN, a[0])
+  end
+
+  def test_ssh_unpack_bn_positive_msb_unset
+    a = Util.ssh_unpack("\x00\x00\x00\x01\x7f\x00\x00\x00\x02\x7f\xff".b, :mpint, :mpint)
+    assert_equal([OpenSSL::BN.new(0x7f), OpenSSL::BN.new(0x7fff)], a)
+    a.each {|o| assert_kind_of(OpenSSL::BN, o) }
+  end
+
+  def test_ssh_unpack_bn_positive_msb_set
+    a = Util.ssh_unpack("\x00\x00\x00\x02\x00\x80\x00\x00\x00\x02\x00\xff\x00\x00\x00\x03\x00\x80\x00\x00\x00\x00\x03\x00\xff\x00".b, :mpint, :mpint, :mpint, :mpint)
+    assert_equal([OpenSSL::BN.new(0x80), OpenSSL::BN.new(0xff), OpenSSL::BN.new(0x8000), OpenSSL::BN.new(0xff00)], a)
+    a.each {|o| assert_kind_of(OpenSSL::BN, o) }
+  end
+
+  def test_ssh_unpack_bn_negative
+    a = Util.ssh_unpack("\x00\x00\x00\x01\xff\x00\x00\x00\x01\x80\x00\x00\x00\x02\xff\x7f\x00\x00\x00\x02\xff\x00".b, :mpint, :mpint, :mpint, :mpint)
+    assert_equal([OpenSSL::BN.new(-0x01), OpenSSL::BN.new(-0x80), OpenSSL::BN.new(-0x81), OpenSSL::BN.new(-0x0100)], a)
+    a.each {|o| assert_kind_of(OpenSSL::BN, o) }
+  end
+
+  def test_ssh_unpack_bn_zero
+    a = Util.ssh_unpack("\x00\x00\x00\x00".b, :mpint)
+    assert_equal([OpenSSL::BN.new(0)], a)
+    assert_kind_of(OpenSSL::BN, a[0])
+  end
+
+  def test_ssh_unpack_bn_rfc_4251_mpint_examples
+    a = Util.ssh_unpack("\x00\x00\x00\x00\x00\x00\x00\x08\x09\xa3\x78\xf9\xb2\xe3\x32\xa7\x00\x00\x00\x02\x00\x80\x00\x00\x00\x02\xed\xcc\x00\x00\x00\x05\xff\x21\x52\x41\x11".b, :mpint, :mpint, :mpint, :mpint, :mpint)
+    assert_equal([OpenSSL::BN.new(0x0), OpenSSL::BN.new(0x9a378f9b2e332a7), OpenSSL::BN.new(0x80), OpenSSL::BN.new(-0x1234), OpenSSL::BN.new(-0xdeadbeef)], a)
+    a.each {|o| assert_kind_of(OpenSSL::BN, o) }
+  end
+
+  def test_ssh_unpack_mixed
+    a = Util.ssh_unpack("\x00\x00\x00\x07string1\x00\x00\x00\x01\x2a\x00\x00\x00\x07string2\x00\x00\x00\x02\x06\xe4".b, :string, :mpint, :string, :mpint)
+    assert_equal(['string1', OpenSSL::BN.new(42), 'string2', OpenSSL::BN.new(1764)], a)
+    assert_kind_of(String, a[0])
+    assert_kind_of(OpenSSL::BN, a[1])
+    assert_kind_of(String, a[2])
+    assert_kind_of(OpenSSL::BN, a[3])
+    assert_equal(Encoding::ASCII_8BIT, a[0].encoding)
+    assert_equal(Encoding::ASCII_8BIT, a[2].encoding)
+  end
+end