rubyntlm 0.6.6 → 0.6.8

data/examples/smtp.rb

@@ -1,94 +0,0 @@
-# $Id: smtp.rb,v 1.2 2006/10/05 01:36:52 koheik Exp $
-require 'socket'
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'net/ntlm'
-
-$user = nil
-$passwd = nil
-
-$host = "localhost"
-$port = 25
-
-$debug = true
-
-def readline(f)
-	(l = f.gets).chomp!
-	puts "srv> " + l if $debug
-	l
-end
-
-def writeline(f, str)
-	puts "cli> " + str if $debug
-	f.print str + "\r\n"
-end
-
-def main
-	s = TCPSocket.new($host, $port)
-
-	# greetings
-	readline s
-	writeline s, "EHLO #{$host}" 
-	while(line = readline(s))
-		login = true if /^250-AUTH=LOGIN/ =~ line
-		ntlm = true if /^250-AUTH.+NTLM.*/ =~ line
-		break if /^250 OK/ =~ line
-	end
-	unless ntlm and login
-		raise RuntimeError, "it looks like the server doesn't support NTLM Login" 
-	end
-	
-	# send Type1 Message
-	t1 = Net::NTLM::Message::Type1.new()
-	writeline s, "AUTH NTLM " + t1.encode64
-
-	# receive Type2 Message, i hope
-	line = readline s
-	unless /334 (.+)/ =~ line
-		raise RuntimeError, "i don't recognize this: #{line}"
-	end
-	t2 = Net::NTLM::Message.decode64($1)
-
-	unless $user and $passwd
-		target = t2.target_name
-		target = Net::NTLM::decode_utf16le(target) if t2.has_flag?(:UNICODE)
-		puts "Target: #{target}"
-		print "User name: "
-		($user = $stdin.readline).chomp!
-		print "Password: "
-		($passwd = $stdin.readline).chomp!
-	end
-	
-	# send Type3 Message
-	t3 = t2.response({:user => $user, :password => $passwd}, {:ntlmv2 => true})
-	writeline s, t3.encode64
-
-	# and result is...
-	line = readline s
-
-	unless /^235(.+)Authentication successful./i =~ line
-		raise RuntimeError, "sorry, authentication failed."
-	end
-	
-	# do real job here like...
-	# from = $user
-	# to = "billg"
-	# writeline s, "MAIL FROM: #{from}"
-	# readline s
-	# writeline s, "RCPT TO: #{to}"
-	# readline s
-	# writeline s, "DATA"
-	# readline s
-	# writeline s, "From: #{from}"
-	# writeline s, "To: #{to}"
-	# writeline s, "blab blab blab..."
-	# writeline s, "#{from}"
-	# writeline s, "."
-	# readline s
-
-	# say bye
-	writeline s, "QUIT"
-	s.close
-end
-
-main
-

data/rubyntlm.gemspec

@@ -1,28 +0,0 @@
-require File.join(File.dirname(__FILE__), 'lib', 'net', 'ntlm', 'version')
-
-Gem::Specification.new do |s|
-  s.platform = Gem::Platform::RUBY
-  s.name = 'rubyntlm'
-  s.version = Net::NTLM::VERSION::STRING
-  s.summary = 'Ruby/NTLM library.'
-  s.description = 'Ruby/NTLM provides message creator and parser for the NTLM authentication.'
-
-  s.authors = ['Kohei Kajimoto','Paul Morton']
-  s.email = ['koheik@gmail.com','paul.e.morton@gmail.com']
-  s.homepage = 'https://github.com/winrb/rubyntlm'
-
-
-  s.files         = `git ls-files`.split($/)
-  s.require_paths = ["lib"]
-
-  s.required_ruby_version = '>= 3.0.0'
-
-  s.license = 'MIT'
-
-  s.add_dependency "base64"
-
-  s.metadata["rubygems_mfa_required"] = "true"
-  s.metadata["source_code_uri"] = s.homepage
-  s.metadata["changelog_uri"] = "#{s.homepage}/blob/master/CHANGELOG.md"
-  s.metadata["bug_tracker_uri"] = "#{s.homepage}/issues"
-end

data/spec/lib/net/ntlm/blob_spec.rb

@@ -1,14 +0,0 @@
-RSpec.describe Net::NTLM::Blob do
-
-  fields = [
-      { :name => :blob_signature, :class => Net::NTLM::Int32LE, :value => 257, :active => true },
-      { :name => :reserved, :class => Net::NTLM::Int32LE, :value => 0, :active => true },
-      { :name => :timestamp, :class => Net::NTLM::Int64LE, :value => 0, :active => true },
-      { :name => :challenge, :class => Net::NTLM::String, :value => '', :active => true },
-      { :name => :unknown1, :class => Net::NTLM::Int32LE, :value => 0, :active => true },
-      { :name => :target_info, :class => Net::NTLM::String, :value => '', :active => true },
-      { :name => :unknown2, :class => Net::NTLM::Int32LE, :value => 0, :active => true },
-  ]
-
-  it_behaves_like 'a fieldset', fields
-end

data/spec/lib/net/ntlm/channel_binding_spec.rb

@@ -1,15 +0,0 @@
-RSpec.describe Net::NTLM::ChannelBinding do
-  let(:certificates_path) { 'spec/support/certificates' }
-  let(:sha_256_path) { File.join(certificates_path, 'sha_256_hash.pem') }
-  let(:sha_256_cert) { OpenSSL::X509::Certificate.new(File.read(sha_256_path)) }  
-  let(:cert_hash) { "\x04\x0E\x56\x28\xEC\x4A\x98\x29\x91\x70\x73\x62\x03\x7B\xB2\x3C".force_encoding(Encoding::ASCII_8BIT) }
-
-  subject { Net::NTLM::ChannelBinding.create(sha_256_cert) }
-
-  describe '#channel_binding_token' do
-
-    it 'returns the correct hash' do
-      expect(subject.channel_binding_token).to eq cert_hash
-    end
-  end
-end

data/spec/lib/net/ntlm/client/session_spec.rb

@@ -1,85 +0,0 @@
-RSpec.describe Net::NTLM::Client::Session do
-  let(:t2_challenge) { Net::NTLM::Message.decode64 "TlRMTVNTUAACAAAADAAMADgAAAA1goriAAyk1DmJUnUAAAAAAAAAAFAAUABEAAAABgLwIwAAAA9TAEUAUgBWAEUAUgACAAwAUwBFAFIAVgBFAFIAAQAMAFMARQBSAFYARQBSAAQADABzAGUAcgB2AGUAcgADAAwAcwBlAHIAdgBlAHIABwAIADd7mrNaB9ABAAAAAA==" }
-  let(:inst) { Net::NTLM::Client::Session.new(nil, t2_challenge) }
-  let(:user_session_key) {["3c4918ff0b33e2603e5d7ceaf34bb7d5"].pack("H*")}
-  let(:client_sign_key) {["f7f97a82ec390f9c903dac4f6aceb132"].pack("H*")}
-  let(:client_seal_key) {["6f0d99535033951cbe499cd1914fe9ee"].pack("H*")}
-  let(:server_sign_key) {["f7f97a82ec390f9c903dac4f6aceb132"].pack("H*")}
-  let(:server_seal_key) {["6f0d99535033951cbe499cd1914fe9ee"].pack("H*")}
-
-  describe "#sign_message" do
-
-    it "signs a message and when KEY_EXCHANGE is true" do
-      expect(inst).to receive(:client_sign_key).and_return(client_sign_key)
-      expect(inst).to receive(:client_seal_key).and_return(client_seal_key)
-      expect(inst).to receive(:negotiate_key_exchange?).and_return(true)
-      sm = inst.sign_message("Test Message")
-      str = "01000000b35ccd60c110c52f00000000"
-      expect(sm.unpack("H*")[0]).to eq(str)
-    end
-
-  end
-
-  describe "#verify_signature" do
-
-    it "verifies a message signature" do
-      expect(inst).to receive(:server_sign_key).and_return(server_sign_key)
-      expect(inst).to receive(:server_seal_key).and_return(server_seal_key)
-      expect(inst).to receive(:negotiate_key_exchange?).and_return(true)
-      sig = "01000000b35ccd60c110c52f00000000"
-      sm = inst.verify_signature([sig].pack("H*"), "Test Message")
-      expect(sm).to be true
-    end
-
-  end
-
-  describe "#seal_message" do
-    it "should seal the message" do
-      expect(inst).to receive(:client_seal_key).and_return(client_seal_key)
-      emsg = inst.seal_message("rubyntlm")
-      expect(emsg.unpack("H*")[0]).to eq("d7389b9604f6274f")
-    end
-  end
-
-  describe "#unseal_message" do
-    it "should unseal the message" do
-      expect(inst).to receive(:server_seal_key).and_return(server_seal_key)
-      msg = inst.unseal_message(["d7389b9604f6274f"].pack("H*"))
-      expect(msg).to eq("rubyntlm")
-    end
-  end
-
-  describe "#exported_session_key" do
-    it "returns a random 16-byte key when negotiate_key_exchange? is true" do
-      expect(inst).to receive(:negotiate_key_exchange?).and_return(true)
-      expect(inst).not_to receive(:user_session_key)
-      inst.exported_session_key
-    end
-
-    it "returns the user_session_key when negotiate_key_exchange? is false" do
-      expect(inst).to receive(:negotiate_key_exchange?).and_return(false)
-      expect(inst).to receive(:user_session_key).and_return(user_session_key)
-      inst.exported_session_key
-    end
-  end
-
-  context 'when authenticating anonymously' do
-    let(:inst) { Net::NTLM::Client::Session.new(Net::NTLM::Client.new('', ''), t2_challenge) }
-
-    describe "#authenticate!" do
-      it "should set the response fields correctly" do
-        t3 = inst.authenticate!
-        expect(t3).to be_a(Net::NTLM::Message::Type3)
-        expect(t3.lm_response).to eq("\x00".b)
-        expect(t3.ntlm_response).to eq('')
-      end
-    end
-
-    describe "#is_anonymous?" do
-      it "should be true" do
-        expect(inst.is_anonymous?).to be_truthy
-      end
-    end
-  end
-
-end

data/spec/lib/net/ntlm/client_spec.rb

@@ -1,62 +0,0 @@
-RSpec.describe Net::NTLM::Client do
-  let(:inst) { Net::NTLM::Client.new("test", "test01", :workstation => "testhost") }
-  let(:user_session_key) {["3c4918ff0b33e2603e5d7ceaf34bb7d5"].pack("H*")}
-
-  describe "#init_context" do
-
-    it "returns a default Type1 message" do
-      t1 = inst.init_context
-      expect(t1).to be_instance_of Net::NTLM::Message::Type1
-      expect(t1.domain).to eq("")
-      expect(t1.workstation).to eq("testhost")
-      expect(t1).to have_flag(:UNICODE)
-      expect(t1).to have_flag(:OEM)
-      expect(t1).to have_flag(:SIGN)
-      expect(t1).to have_flag(:SEAL)
-      expect(t1).to have_flag(:REQUEST_TARGET)
-      expect(t1).to have_flag(:NTLM)
-      expect(t1).to have_flag(:ALWAYS_SIGN)
-      expect(t1).to have_flag(:NTLM2_KEY)
-      expect(t1).to have_flag(:KEY128)
-      expect(t1).to have_flag(:KEY_EXCHANGE)
-      expect(t1).to have_flag(:KEY56)
-    end
-
-    it "clears session variable on new init_context" do
-      inst.instance_variable_set :@session, "BADSESSION"
-      expect(inst.session).to eq("BADSESSION")
-      inst.init_context
-      expect(inst.session).to be_nil
-    end
-
-    it "returns a Type1 message with custom flags" do
-      flags = Net::NTLM::FLAGS[:UNICODE] | Net::NTLM::FLAGS[:REQUEST_TARGET] | Net::NTLM::FLAGS[:NTLM]
-      inst = Net::NTLM::Client.new("test", "test01", :workstation => "testhost", :flags => flags)
-      t1 = inst.init_context
-      expect(t1).to be_instance_of Net::NTLM::Message::Type1
-      expect(t1.domain).to eq("")
-      expect(t1.workstation).to eq("testhost")
-      expect(t1).to have_flag(:UNICODE)
-      expect(t1).not_to have_flag(:OEM)
-      expect(t1).not_to have_flag(:SIGN)
-      expect(t1).not_to have_flag(:SEAL)
-      expect(t1).to have_flag(:REQUEST_TARGET)
-      expect(t1).to have_flag(:NTLM)
-      expect(t1).not_to have_flag(:ALWAYS_SIGN)
-      expect(t1).not_to have_flag(:NTLM2_KEY)
-      expect(t1).not_to have_flag(:KEY128)
-      expect(t1).not_to have_flag(:KEY_EXCHANGE)
-      expect(t1).not_to have_flag(:KEY56)
-    end
-
-    it "calls authenticate! when we receive a Challenge Message" do
-      t2_challenge = "TlRMTVNTUAACAAAADAAMADgAAAA1goriAAyk1DmJUnUAAAAAAAAAAFAAUABEAAAABgLwIwAAAA9TAEUAUgBWAEUAUgACAAwAUwBFAFIAVgBFAFIAAQAMAFMARQBSAFYARQBSAAQADABzAGUAcgB2AGUAcgADAAwAcwBlAHIAdgBlAHIABwAIADd7mrNaB9ABAAAAAA=="
-      session = double("session")
-      expect(session).to receive(:authenticate!)
-      expect(Net::NTLM::Client::Session).to receive(:new).with(inst, instance_of(Net::NTLM::Message::Type2), nil).and_return(session)
-      inst.init_context t2_challenge
-    end
-
-  end
-
-end

data/spec/lib/net/ntlm/encode_util_spec.rb

@@ -1,14 +0,0 @@
-RSpec.describe Net::NTLM::EncodeUtil do
-
-  context '#encode_utf16le' do
-    it 'should convert an ASCII string to UTF' do
-      expect(Net::NTLM::EncodeUtil.encode_utf16le('Test'.encode(::Encoding::ASCII_8BIT).freeze)).to eq("T\x00e\x00s\x00t\x00")
-    end
-  end
-
-  context '#decode_utf16le' do
-    it 'should convert a UTF string to ASCII' do
-      expect(Net::NTLM::EncodeUtil.decode_utf16le("T\x00e\x00s\x00t\x00".freeze)).to eq('Test')
-    end
-  end
-end

data/spec/lib/net/ntlm/field_set_spec.rb

@@ -1,31 +0,0 @@
-RSpec.describe Net::NTLM::FieldSet do
-
-  fields = []
-
-  it_behaves_like 'a fieldset', fields
-
-  subject(:fieldset_class) do
-    Class.new(Net::NTLM::FieldSet)
-  end
-
-  context 'an instance' do
-    subject(:fieldset_object) do
-      fieldset_class.string(:test_string, { :value => 'Test', :active => true, :size => 4})
-      fieldset_class.string(:test_string2, { :value => 'Foo', :active => true, :size => 3})
-      fieldset_class.new
-    end
-
-    it 'should serialize all the fields' do
-      expect(fieldset_object.serialize).to eq('TestFoo')
-    end
-
-    it 'should parse a string across the fields' do
-      fieldset_object.parse('FooBarBaz')
-      expect(fieldset_object.serialize).to eq('FooBarB')
-    end
-
-    it 'should return an aggregate size of all the fields' do
-      expect(fieldset_object.size).to eq(7)
-    end
-  end
-end

data/spec/lib/net/ntlm/field_spec.rb

@@ -1,32 +0,0 @@
-RSpec.describe Net::NTLM::Field do
-
-  it_behaves_like 'a field', 'Foo', false
-
-  context 'with no size specified' do
-    let (:field_without_size) { Net::NTLM::Field.new({ :value => 'Foo', :active => true }) }
-    it 'should set size to 0 if not active' do
-      expect(field_without_size.size).to eq(0)
-    end
-
-    it 'should return 0 if active but no size specified' do
-      field_without_size.active = true
-      expect(field_without_size.size).to eq(0)
-    end
-  end
-
-  context 'with a size specified' do
-    let (:field_with_size) { Net::NTLM::Field.new({ :value => 'Foo', :active => true, :size => 100 }) }
-
-    it 'should return the size provided in the initialize options if active' do
-      expect(field_with_size.size).to eq(100)
-    end
-
-    it 'should still return 0 if not active' do
-      field_with_size.active = false
-      expect(field_with_size.size).to eq(0)
-    end
-  end
-
-
-
-end

data/spec/lib/net/ntlm/int16_le_spec.rb

@@ -1,16 +0,0 @@
-RSpec.describe Net::NTLM::Int16LE do
-
-  int_values = {
-    :default     => 15,
-    :default_hex => "\x0F\x00",
-    :alt         => 14,
-    :alt_hex     => "\x0E\x00",
-    :small       => "\x0F",
-    :size        => 2,
-    :bits        => 16
-  }
-
-  it_behaves_like 'a field', 15, false
-  it_behaves_like 'an integer field', int_values
-
-end

data/spec/lib/net/ntlm/int32_le_spec.rb

@@ -1,17 +0,0 @@
-RSpec.describe Net::NTLM::Int32LE do
-
-  int_values = {
-      :default     => 252716124,
-      :default_hex => "\x5C\x24\x10\x0f",
-      :alt         => 235938908,
-      :alt_hex     => "\x5C\x24\x10\x0e",
-      :small       => "\x0F\x00",
-      :size        => 4,
-      :bits        => 32
-  }
-
-
-  it_behaves_like 'a field', 252716124, false
-  it_behaves_like 'an integer field', int_values
-
-end

data/spec/lib/net/ntlm/int64_le_spec.rb

@@ -1,17 +0,0 @@
-RSpec.describe Net::NTLM::Int64LE do
-
-  int_values = {
-      :default     => 5294967295,
-      :default_hex => [5294967295 & 0x00000000ffffffff, 5294967295 >> 32].pack("V2"),
-      :alt         => 5294967294,
-      :alt_hex     => [5294967294 & 0x00000000ffffffff, 5294967294 >> 32].pack("V2"),
-      :small       => "\x5C\x24\x10\x0f",
-      :size        => 8,
-      :bits        => 64
-  }
-
-
-  it_behaves_like 'a field', 252716124, false
-  it_behaves_like 'an integer field', int_values
-
-end

data/spec/lib/net/ntlm/md4_spec.rb

@@ -1,16 +0,0 @@
-RSpec.describe Net::NTLM::Md4 do
-  describe '.digest' do
-    it 'hashes binary input containing high bytes' do
-      # Independently calculated with OpenSSL's legacy MD4 provider.
-      expect(described_class.digest("\xff".b).unpack('H*').first).
-        to eq('82c167af8e345bd055487af8d2b540c9')
-    end
-
-    it 'preserves the caller input and encoding' do
-      input = "\xff".b.freeze
-      described_class.digest(input)
-      expect(input).to eq("\xff".b)
-      expect(input.encoding).to eq(Encoding::ASCII_8BIT)
-    end
-  end
-end

data/spec/lib/net/ntlm/message/type0_spec.rb

@@ -1,19 +0,0 @@
-RSpec.describe Net::NTLM::Message::Type0 do
-
-  fields = [
-      { :name => :sign, :class => Net::NTLM::String, :value => Net::NTLM::SSP_SIGN, :active => true },
-      { :name => :type, :class => Net::NTLM::Int32LE, :value => 0, :active => true },
-  ]
-  flags = [
-      :UNICODE,
-      :OEM,
-      :REQUEST_TARGET,
-      :NTLM,
-      :ALWAYS_SIGN,
-      :NTLM2_KEY
-  ]
-  it_behaves_like 'a fieldset', fields
-  it_behaves_like 'a message', flags
-
-
-end

data/spec/lib/net/ntlm/message/type1_spec.rb

@@ -1,129 +0,0 @@
-RSpec.describe Net::NTLM::Message::Type1 do
-  fields = [
-      { :name => :sign, :class => Net::NTLM::String, :value => Net::NTLM::SSP_SIGN, :active => true },
-      { :name => :type, :class => Net::NTLM::Int32LE, :value => 1, :active => true },
-      { :name => :flag, :class => Net::NTLM::Int32LE, :value =>  Net::NTLM::DEFAULT_FLAGS[:TYPE1], :active => true },
-      { :name => :domain, :class => Net::NTLM::SecurityBuffer, :value => '', :active => true },
-      { :name => :workstation, :class => Net::NTLM::SecurityBuffer, :value =>  Socket.gethostname, :active => true },
-      { :name => :os_version, :class => Net::NTLM::String, :value => '', :active => false },
-  ]
-  flags = [
-      :UNICODE,
-      :OEM,
-      :REQUEST_TARGET,
-      :NTLM,
-      :ALWAYS_SIGN,
-      :NTLM2_KEY
-  ]
-  it_behaves_like 'a fieldset', fields
-  it_behaves_like 'a message', flags
-
-  let(:type1_packet) {"TlRMTVNTUAABAAAAB4IIAAAAAAAgAAAAAAAAACAAAAA="}
-
-  it 'should deserialize' do
-    t1 =  Net::NTLM::Message.decode64(type1_packet)
-    expect(t1.class).to eq(Net::NTLM::Message::Type1)
-    expect(t1.domain).to eq('')
-    expect(t1.flag).to eq(557575)
-    expect(t1.os_version).to eq('')
-    expect(t1.sign).to eq("NTLMSSP\0")
-    expect(t1.type).to eq(1)
-    expect(t1.workstation).to eq('')
-  end
-
-  it 'should serialize' do
-    t1 = Net::NTLM::Message::Type1.new
-    t1.workstation = ''
-    expect(t1.encode64).to eq(type1_packet)
-  end
-
-  describe '.parse' do
-    subject(:message) { described_class.parse(data) }
-    # http://davenport.sourceforge.net/ntlm.html#appendixC7
-    context 'NTLM2 Session Response Authentication; NTLM2 Signing and Sealing Using the 128-bit NTLM2 Session Response User Session Key With Key Exchange Negotiated' do
-      let(:data) do
-        ['4e544c4d5353500001000000b78208e000000000000000000000000000000000'].pack('H*')
-      end
-
-      it 'should set the magic' do
-        expect(message.sign).to eql(Net::NTLM::SSP_SIGN)
-      end
-      it 'should set the type' do
-        expect(message.type).to eq(1)
-      end
-      it 'should set the flags' do
-        expect(message.flag).to eq(0xe00882b7)
-        expect(message).to have_flag(:UNICODE)
-        expect(message).to have_flag(:OEM)
-        expect(message).to have_flag(:REQUEST_TARGET)
-        expect(message).to have_flag(:SIGN)
-        expect(message).to have_flag(:SEAL)
-        expect(message).to have_flag(:NTLM)
-        expect(message).to have_flag(:ALWAYS_SIGN)
-        expect(message).to have_flag(:NTLM2_KEY)
-        expect(message).to have_flag(:KEY128)
-        expect(message).to have_flag(:KEY_EXCHANGE)
-        expect(message).to have_flag(:KEY56)
-      end
-      it 'should have empty workstation' do
-        expect(message.workstation).to be_empty
-      end
-      it 'should have empty domain' do
-        expect(message.domain).to be_empty
-      end
-
-    end
-
-    # http://davenport.sourceforge.net/ntlm.html#appendixC9
-    context 'NTLMv2 Authentication; NTLM1 Signing and Sealing Using the 40-bit NTLMv2 User Session Key' do
-      let(:data) { ['4e544c4d53535000010000003782000000000000000000000000000000000000'].pack('H*') }
-
-      it 'should set the magic' do
-        expect(message.sign).to eql(Net::NTLM::SSP_SIGN)
-      end
-      it 'should set the type' do
-        expect(message.type).to eq(1)
-      end
-      it 'should set the flags' do
-        expect(message.flag).to eq(0x00008237)
-        expect(message).to have_flag(:UNICODE)
-        expect(message).to have_flag(:OEM)
-        expect(message).to have_flag(:REQUEST_TARGET)
-        expect(message).to have_flag(:SIGN)
-        expect(message).to have_flag(:SEAL)
-        expect(message).to have_flag(:NTLM)
-        expect(message).to have_flag(:ALWAYS_SIGN)
-      end
-      it 'should have empty workstation' do
-        expect(message.workstation).to be_empty
-      end
-      it 'should have empty domain' do
-        expect(message.domain).to be_empty
-      end
-    end
-
-    context 'NTLMv2 with OS version' do
-      let(:data) { ['4e544c4d5353500001000000978208e2000000000000000000000000000000000602f0230000000f'].pack('H*') }
-
-      it 'should set the magic' do
-        expect(message.sign).to eql(Net::NTLM::SSP_SIGN)
-      end
-      it 'should set the type' do
-        expect(message.type).to eq(1)
-      end
-      it 'should have empty workstation' do
-        expect(message.workstation).to be_empty
-      end
-      it 'should have empty domain' do
-        expect(message.domain).to be_empty
-      end
-
-      it 'should set OS version info' do
-        expect(message.os_version).to eq(['0602f0230000000f'].pack('H*'))
-      end
-
-    end
-
-  end
-
-end