rubyntlm 0.5.3 → 0.6.0

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

@@ -1,17 +1,17 @@
-require 'spec_helper'
-
-describe Net::NTLM::Message do
-
-  fields = []
-  flags = [
-      :UNICODE,
-      :OEM,
-      :REQUEST_TARGET,
-      :NTLM,
-      :ALWAYS_SIGN,
-      :NTLM2_KEY
-  ]
-  it_behaves_like 'a fieldset', fields
-  it_behaves_like 'a message', flags
-
+require 'spec_helper'
+
+describe Net::NTLM::Message do
+
+  fields = []
+  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/security_buffer_spec.rb

@@ -1,64 +1,64 @@
-require 'spec_helper'
-
-describe Net::NTLM::SecurityBuffer do
-
-  fields = [
-      { :name => :length, :class => Net::NTLM::Int16LE, :value => 0, :active => true },
-      { :name => :allocated, :class => Net::NTLM::Int16LE, :value => 0, :active => true },
-      { :name => :offset, :class => Net::NTLM::Int32LE, :value => 0, :active => true },
-  ]
-
-  it_behaves_like 'a fieldset', fields
-  it_behaves_like 'a field', 'WORKSTATION', true
-
-
-  subject(:domain_security_buffer) do
-    Net::NTLM::SecurityBuffer.new({
-        :value => 'WORKSTATION',
-        :active => true
-    })
-  end
-
-  context 'when setting the value directly' do
-    before(:each) do
-      domain_security_buffer.value = 'DOMAIN1'
-    end
-    it 'should change the value' do
-      expect(domain_security_buffer.value).to eq('DOMAIN1')
-    end
-
-    it 'should adjust the length field to the size of the new value' do
-      expect(domain_security_buffer.length).to eq(7)
-    end
-
-    it 'should adjust the allocated field to the size of the new value' do
-      expect(domain_security_buffer.allocated).to eq(7)
-    end
-  end
-
-  context '#data_size' do
-    it 'should return the size of the value if active' do
-      expect(domain_security_buffer.data_size).to eq(11)
-    end
-
-    it 'should return 0 if inactive' do
-      domain_security_buffer.active = false
-      expect(domain_security_buffer.data_size).to eq(0)
-    end
-  end
-
-  context '#parse' do
-    it 'should read in a properly formatted string' do
-      # Length of the string is 8
-      length = "\x08\x00"
-      # Space allocated is 8
-      allocated = "\x08\x00"
-      # The offset that the actual value begins at is also 8
-      offset = "\x08\x00\x00\x00"
-      string_to_parse = "#{length}#{allocated}#{offset}FooBarBaz"
-      expect(domain_security_buffer.parse(string_to_parse)).to eq(8)
-      expect(domain_security_buffer.value).to eq('FooBarBa')
-    end
-
-  end
-end
+require 'spec_helper'
+
+describe Net::NTLM::SecurityBuffer do
+
+  fields = [
+      { :name => :length, :class => Net::NTLM::Int16LE, :value => 0, :active => true },
+      { :name => :allocated, :class => Net::NTLM::Int16LE, :value => 0, :active => true },
+      { :name => :offset, :class => Net::NTLM::Int32LE, :value => 0, :active => true },
+  ]
+
+  it_behaves_like 'a fieldset', fields
+  it_behaves_like 'a field', 'WORKSTATION', true
+
+
+  subject(:domain_security_buffer) do
+    Net::NTLM::SecurityBuffer.new({
+        :value => 'WORKSTATION',
+        :active => true
+    })
+  end
+
+  context 'when setting the value directly' do
+    before(:each) do
+      domain_security_buffer.value = 'DOMAIN1'
+    end
+    it 'should change the value' do
+      expect(domain_security_buffer.value).to eq('DOMAIN1')
+    end
+
+    it 'should adjust the length field to the size of the new value' do
+      expect(domain_security_buffer.length).to eq(7)
+    end
+
+    it 'should adjust the allocated field to the size of the new value' do
+      expect(domain_security_buffer.allocated).to eq(7)
+    end
+  end
+
+  context '#data_size' do
+    it 'should return the size of the value if active' do
+      expect(domain_security_buffer.data_size).to eq(11)
+    end
+
+    it 'should return 0 if inactive' do
+      domain_security_buffer.active = false
+      expect(domain_security_buffer.data_size).to eq(0)
+    end
+  end
+
+  context '#parse' do
+    it 'should read in a properly formatted string' do
+      # Length of the string is 8
+      length = "\x08\x00"
+      # Space allocated is 8
+      allocated = "\x08\x00"
+      # The offset that the actual value begins at is also 8
+      offset = "\x08\x00\x00\x00"
+      string_to_parse = "#{length}#{allocated}#{offset}FooBarBaz"
+      expect(domain_security_buffer.parse(string_to_parse)).to eq(8)
+      expect(domain_security_buffer.value).to eq('FooBarBa')
+    end
+
+  end
+end

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

@@ -1,72 +1,72 @@
-require 'spec_helper'
-
-describe Net::NTLM::String do
-
-  it_behaves_like 'a field', 'Foo', false
-
-  let(:active) {
-    Net::NTLM::String.new({
-        :value  => 'Test',
-        :active => true,
-        :size   => 4
-    })
-  }
-
-  let(:inactive) {
-    Net::NTLM::String.new({
-        :value  => 'Test',
-        :active => false,
-        :size   => 4
-    })
-  }
-
-  context '#serialize' do
-    it 'should return the value when active' do
-      expect(active.serialize).to eq('Test')
-    end
-
-    it 'should return an empty string when inactive' do
-      expect(inactive.serialize).to eq('')
-    end
-
-    it 'should coerce non-string values into strings' do
-      active.value = 15
-      expect(active.serialize).to eq('15')
-    end
-
-    it 'should return empty string on a nil' do
-      active.value = nil
-      expect(active.serialize).to eq('')
-    end
-  end
-
-  context '#value=' do
-    it 'should set active to false if it empty' do
-      active.value = ''
-      expect(active.active).to eq(false)
-    end
-
-    it 'should adjust the size based on the value set' do
-      expect(active.size).to eq(4)
-      active.value = 'Foobar'
-      expect(active.size).to eq(6)
-    end
-  end
-
-  context '#parse' do
-    it 'should read in a string of the proper size' do
-      expect(active.parse('tseT')).to eq(4)
-      expect(active.value).to eq('tseT')
-    end
-
-    it 'should not read in a string that is too small' do
-      expect(active.parse('B')).to eq(0)
-      expect(active.value).to eq('Test')
-    end
-
-    it 'should be able to read from an offset and only for the given size' do
-      expect(active.parse('FooBarBaz',3)).to eq(4)
-      expect(active.value).to eq('BarB')
-    end
-  end
-end
+require 'spec_helper'
+
+describe Net::NTLM::String do
+
+  it_behaves_like 'a field', 'Foo', false
+
+  let(:active) {
+    Net::NTLM::String.new({
+        :value  => 'Test',
+        :active => true,
+        :size   => 4
+    })
+  }
+
+  let(:inactive) {
+    Net::NTLM::String.new({
+        :value  => 'Test',
+        :active => false,
+        :size   => 4
+    })
+  }
+
+  context '#serialize' do
+    it 'should return the value when active' do
+      expect(active.serialize).to eq('Test')
+    end
+
+    it 'should return an empty string when inactive' do
+      expect(inactive.serialize).to eq('')
+    end
+
+    it 'should coerce non-string values into strings' do
+      active.value = 15
+      expect(active.serialize).to eq('15')
+    end
+
+    it 'should return empty string on a nil' do
+      active.value = nil
+      expect(active.serialize).to eq('')
+    end
+  end
+
+  context '#value=' do
+    it 'should set active to false if it empty' do
+      active.value = ''
+      expect(active.active).to eq(false)
+    end
+
+    it 'should adjust the size based on the value set' do
+      expect(active.size).to eq(4)
+      active.value = 'Foobar'
+      expect(active.size).to eq(6)
+    end
+  end
+
+  context '#parse' do
+    it 'should read in a string of the proper size' do
+      expect(active.parse('tseT')).to eq(4)
+      expect(active.value).to eq('tseT')
+    end
+
+    it 'should not read in a string that is too small' do
+      expect(active.parse('B')).to eq(0)
+      expect(active.value).to eq('Test')
+    end
+
+    it 'should be able to read from an offset and only for the given size' do
+      expect(active.parse('FooBarBaz',3)).to eq(4)
+      expect(active.value).to eq('BarB')
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Net::NTLM::TargetInfo do
+  let(:key1) { Net::NTLM::TargetInfo::MSV_AV_NB_COMPUTER_NAME }
+  let(:value1) { 'some data' }
+  let(:key2) { Net::NTLM::TargetInfo::MSV_AV_NB_DOMAIN_NAME }
+  let(:value2) { 'some other data' }  
+  let(:data) do
+    dt = key1.dup
+    dt << [value1.length].pack('S')
+    dt << value1
+    dt << key2.dup
+    dt << [value2.length].pack('S')
+    dt << value2
+    dt << Net::NTLM::TargetInfo::MSV_AV_EOL
+    dt << [0].pack('S')
+    dt.force_encoding(Encoding::ASCII_8BIT)
+  end
+
+  subject { Net::NTLM::TargetInfo.new(data) }
+
+  describe 'invalid data' do
+
+    context 'invalid pair id' do
+      let(:data) { "\xFF\x00" }
+
+      it 'returns an error' do
+        expect{subject}.to raise_error Net::NTLM::InvalidTargetDataError
+      end    
+    end
+  end
+
+  describe '#av_pairs' do
+
+    it 'returns the pair values with the given keys' do
+      expect(subject.av_pairs[key1]).to eq value1
+      expect(subject.av_pairs[key2]).to eq value2
+    end
+
+    context "target data is nil" do
+      subject { Net::NTLM::TargetInfo.new(nil) }
+
+      it 'returns the pair values with the given keys' do
+        expect(subject.av_pairs).to be_empty
+      end
+    end
+  end
+
+  describe '#to_s' do
+    let(:data) do
+      dt = key1.dup
+      dt << [value1.length].pack('S')
+      dt << value1
+      dt << key2.dup
+      dt << [value2.length].pack('S')
+      dt << value2
+      dt.force_encoding(Encoding::ASCII_8BIT)
+    end
+    let(:new_key) { Net::NTLM::TargetInfo::MSV_AV_CHANNEL_BINDINGS }
+    let(:new_value) { 'bindings' }
+    let(:new_data) do
+      dt = data
+      dt << new_key
+      dt << [new_value.length].pack('S')
+      dt << new_value
+      dt << Net::NTLM::TargetInfo::MSV_AV_EOL
+      dt << [0].pack('S')
+      dt.force_encoding(Encoding::ASCII_8BIT)
+    end
+
+    it 'returns bytes with any new data added' do
+      subject.av_pairs[new_key] = new_value
+      expect(subject.to_s).to eq new_data
+    end
+  end
+end

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

@@ -1,27 +1,27 @@
-require 'spec_helper'
-require File.expand_path("#{File.dirname(__FILE__)}/../../../../lib/net/ntlm/version")
-
-describe Net::NTLM::VERSION do
-
-  it 'should contain an integer value for Major Version' do
-    expect(Net::NTLM::VERSION::MAJOR).to be_an Integer
-  end
-
-  it 'should contain an integer value for Minor Version' do
-    expect(Net::NTLM::VERSION::MINOR).to be_an Integer
-  end
-
-  it 'should contain an integer value for Patch Version' do
-    expect(Net::NTLM::VERSION::TINY).to be_an Integer
-  end
-
-  it 'should contain an aggregate version string' do
-    string = [
-        Net::NTLM::VERSION::MAJOR,
-        Net::NTLM::VERSION::MINOR,
-        Net::NTLM::VERSION::TINY
-    ].join('.')
-    expect(Net::NTLM::VERSION::STRING).to be_a String
-    expect(Net::NTLM::VERSION::STRING).to eq(string)
-  end
-end
+require 'spec_helper'
+require File.expand_path("#{File.dirname(__FILE__)}/../../../../lib/net/ntlm/version")
+
+describe Net::NTLM::VERSION do
+
+  it 'should contain an integer value for Major Version' do
+    expect(Net::NTLM::VERSION::MAJOR).to be_an Integer
+  end
+
+  it 'should contain an integer value for Minor Version' do
+    expect(Net::NTLM::VERSION::MINOR).to be_an Integer
+  end
+
+  it 'should contain an integer value for Patch Version' do
+    expect(Net::NTLM::VERSION::TINY).to be_an Integer
+  end
+
+  it 'should contain an aggregate version string' do
+    string = [
+        Net::NTLM::VERSION::MAJOR,
+        Net::NTLM::VERSION::MINOR,
+        Net::NTLM::VERSION::TINY
+    ].join('.')
+    expect(Net::NTLM::VERSION::STRING).to be_a String
+    expect(Net::NTLM::VERSION::STRING).to eq(string)
+  end
+end

data/spec/lib/net/ntlm_spec.rb

@@ -1,127 +1,127 @@
-require "spec_helper"
-
-describe Net::NTLM do
-  let(:passwd) {"SecREt01"}
-  let(:user) {"user"}
-  let(:domain) {"DOMAIN"}
-  let(:challenge) {["0123456789abcdef"].pack("H*")}
-  let(:client_ch) {["ffffff0011223344"].pack("H*")}
-  let(:timestamp) {1055844000}
-  let(:trgt_info) {[
-      "02000c0044004f004d00410049004e00" +
-      "01000c00530045005200560045005200" +
-      "0400140064006f006d00610069006e00" +
-      "2e0063006f006d000300220073006500" +
-      "72007600650072002e0064006f006d00" +
-      "610069006e002e0063006f006d000000" +
-      "0000"
-  ].pack("H*")}
-  let(:padded_pwd) { passwd.upcase.ljust(14, "\0")}
-  let(:keys) { Net::NTLM.gen_keys(padded_pwd)}
-
-  it 'should convert a value to 64-bit LE Integer' do
-    expect(Net::NTLM.pack_int64le(42)).to eq("\x2A\x00\x00\x00\x00\x00\x00\x00")
-  end
-
-  it 'should split a string into an array of slices, 7 chars or less' do
-    expect(Net::NTLM.split7("HelloWorld!")).to eq([ 'HelloWo', 'rld!'])
-  end
-
-  it 'should generate DES keys from the supplied string' do
-    first_key = ["52a2516b252a5161"].pack('H*')
-    second_key = ["3180010101010101"].pack('H*')
-    expect(Net::NTLM.gen_keys(padded_pwd)).to eq([first_key, second_key])
-  end
-
-  it 'should encrypt the string with DES for each key supplied' do
-    first_crypt = ["ff3750bcc2b22412"].pack('H*')
-    second_crypt = ["c2265b23734e0dac"].pack('H*')
-    expect(Net::NTLM::apply_des(Net::NTLM::LM_MAGIC, keys)).to eq([first_crypt, second_crypt])
-  end
-
-  it 'should generate an lm_hash' do
-    expect(Net::NTLM::lm_hash(passwd)).to eq(["ff3750bcc2b22412c2265b23734e0dac"].pack("H*"))
-  end
-
-  it 'should generate an ntlm_hash' do
-    expect(Net::NTLM::ntlm_hash(passwd)).to eq(["cd06ca7c7e10c99b1d33b7485a2ed808"].pack("H*"))
-  end
-
-  it 'should generate an ntlmv2_hash' do
-    expect(Net::NTLM::ntlmv2_hash(user, passwd, domain)).to eq(["04b8e0ba74289cc540826bab1dee63ae"].pack("H*"))
-  end
-
-  context 'when a user passes an NTLM hash for pass-the-hash' do
-    let(:passwd) { Net::NTLM::EncodeUtil.encode_utf16le('ff3750bcc2b22412c2265b23734e0dac:cd06ca7c7e10c99b1d33b7485a2ed808') }
-
-    it 'should return the correct ntlmv2 hash' do
-      expect(Net::NTLM::ntlmv2_hash(user, passwd, domain)).to eq(["04b8e0ba74289cc540826bab1dee63ae"].pack("H*"))
-    end
-  end
-
-  it 'should generate an lm_response' do
-    expect(Net::NTLM::lm_response(
-        {
-            :lm_hash => Net::NTLM::lm_hash(passwd),
-            :challenge => challenge
-        }
-    )).to eq(["c337cd5cbd44fc9782a667af6d427c6de67c20c2d3e77c56"].pack("H*"))
-  end
-
-  it 'should generate an ntlm_response' do
-    ntlm_hash = Net::NTLM::ntlm_hash(passwd)
-    expect(Net::NTLM::ntlm_response(
-        {
-            :ntlm_hash => ntlm_hash,
-            :challenge => challenge
-        }
-    )).to eq(["25a98c1c31e81847466b29b2df4680f39958fb8c213a9cc6"].pack("H*"))
-  end
-
-  it 'should generate a lvm2_response' do
-    expect(Net::NTLM::lmv2_response(
-        {
-            :ntlmv2_hash => Net::NTLM::ntlmv2_hash(user, passwd, domain),
-            :challenge => challenge
-        },
-        { :client_challenge => client_ch }
-    )).to eq(["d6e6152ea25d03b7c6ba6629c2d6aaf0ffffff0011223344"].pack("H*"))
-  end
-
-  it 'should generate a ntlmv2_response' do
-    expect(Net::NTLM::ntlmv2_response(
-        {
-            :ntlmv2_hash => Net::NTLM::ntlmv2_hash(user, passwd, domain),
-            :challenge => challenge,
-            :target_info => trgt_info
-        },
-        {
-            :timestamp => timestamp,
-            :client_challenge => client_ch
-        }
-    )).to eq([
-        "cbabbca713eb795d04c97abc01ee4983" +
-        "01010000000000000090d336b734c301" +
-        "ffffff00112233440000000002000c00" +
-        "44004f004d00410049004e0001000c00" +
-        "53004500520056004500520004001400" +
-        "64006f006d00610069006e002e006300" +
-        "6f006d00030022007300650072007600" +
-        "650072002e0064006f006d0061006900" +
-        "6e002e0063006f006d00000000000000" +
-        "0000"
-    ].pack("H*"))
-  end
-
-  it 'should generate a ntlm2_session' do
-    session = Net::NTLM::ntlm2_session(
-        {
-            :ntlm_hash => Net::NTLM::ntlm_hash(passwd),
-            :challenge => challenge
-        },
-        { :client_challenge => client_ch }
-    )
-    expect(session[0]).to eq(["ffffff001122334400000000000000000000000000000000"].pack("H*"))
-    expect(session[1]).to eq(["10d550832d12b2ccb79d5ad1f4eed3df82aca4c3681dd455"].pack("H*"))
-  end
-end
+require "spec_helper"
+
+describe Net::NTLM do
+  let(:passwd) {"SecREt01"}
+  let(:user) {"user"}
+  let(:domain) {"DOMAIN"}
+  let(:challenge) {["0123456789abcdef"].pack("H*")}
+  let(:client_ch) {["ffffff0011223344"].pack("H*")}
+  let(:timestamp) {1055844000}
+  let(:trgt_info) {[
+      "02000c0044004f004d00410049004e00" +
+      "01000c00530045005200560045005200" +
+      "0400140064006f006d00610069006e00" +
+      "2e0063006f006d000300220073006500" +
+      "72007600650072002e0064006f006d00" +
+      "610069006e002e0063006f006d000000" +
+      "0000"
+  ].pack("H*")}
+  let(:padded_pwd) { passwd.upcase.ljust(14, "\0")}
+  let(:keys) { Net::NTLM.gen_keys(padded_pwd)}
+
+  it 'should convert a value to 64-bit LE Integer' do
+    expect(Net::NTLM.pack_int64le(42)).to eq("\x2A\x00\x00\x00\x00\x00\x00\x00")
+  end
+
+  it 'should split a string into an array of slices, 7 chars or less' do
+    expect(Net::NTLM.split7("HelloWorld!")).to eq([ 'HelloWo', 'rld!'])
+  end
+
+  it 'should generate DES keys from the supplied string' do
+    first_key = ["52a2516b252a5161"].pack('H*')
+    second_key = ["3180010101010101"].pack('H*')
+    expect(Net::NTLM.gen_keys(padded_pwd)).to eq([first_key, second_key])
+  end
+
+  it 'should encrypt the string with DES for each key supplied' do
+    first_crypt = ["ff3750bcc2b22412"].pack('H*')
+    second_crypt = ["c2265b23734e0dac"].pack('H*')
+    expect(Net::NTLM::apply_des(Net::NTLM::LM_MAGIC, keys)).to eq([first_crypt, second_crypt])
+  end
+
+  it 'should generate an lm_hash' do
+    expect(Net::NTLM::lm_hash(passwd)).to eq(["ff3750bcc2b22412c2265b23734e0dac"].pack("H*"))
+  end
+
+  it 'should generate an ntlm_hash' do
+    expect(Net::NTLM::ntlm_hash(passwd)).to eq(["cd06ca7c7e10c99b1d33b7485a2ed808"].pack("H*"))
+  end
+
+  it 'should generate an ntlmv2_hash' do
+    expect(Net::NTLM::ntlmv2_hash(user, passwd, domain)).to eq(["04b8e0ba74289cc540826bab1dee63ae"].pack("H*"))
+  end
+
+  context 'when a user passes an NTLM hash for pass-the-hash' do
+    let(:passwd) { Net::NTLM::EncodeUtil.encode_utf16le('ff3750bcc2b22412c2265b23734e0dac:cd06ca7c7e10c99b1d33b7485a2ed808') }
+
+    it 'should return the correct ntlmv2 hash' do
+      expect(Net::NTLM::ntlmv2_hash(user, passwd, domain)).to eq(["04b8e0ba74289cc540826bab1dee63ae"].pack("H*"))
+    end
+  end
+
+  it 'should generate an lm_response' do
+    expect(Net::NTLM::lm_response(
+        {
+            :lm_hash => Net::NTLM::lm_hash(passwd),
+            :challenge => challenge
+        }
+    )).to eq(["c337cd5cbd44fc9782a667af6d427c6de67c20c2d3e77c56"].pack("H*"))
+  end
+
+  it 'should generate an ntlm_response' do
+    ntlm_hash = Net::NTLM::ntlm_hash(passwd)
+    expect(Net::NTLM::ntlm_response(
+        {
+            :ntlm_hash => ntlm_hash,
+            :challenge => challenge
+        }
+    )).to eq(["25a98c1c31e81847466b29b2df4680f39958fb8c213a9cc6"].pack("H*"))
+  end
+
+  it 'should generate a lvm2_response' do
+    expect(Net::NTLM::lmv2_response(
+        {
+            :ntlmv2_hash => Net::NTLM::ntlmv2_hash(user, passwd, domain),
+            :challenge => challenge
+        },
+        { :client_challenge => client_ch }
+    )).to eq(["d6e6152ea25d03b7c6ba6629c2d6aaf0ffffff0011223344"].pack("H*"))
+  end
+
+  it 'should generate a ntlmv2_response' do
+    expect(Net::NTLM::ntlmv2_response(
+        {
+            :ntlmv2_hash => Net::NTLM::ntlmv2_hash(user, passwd, domain),
+            :challenge => challenge,
+            :target_info => trgt_info
+        },
+        {
+            :timestamp => timestamp,
+            :client_challenge => client_ch
+        }
+    )).to eq([
+        "cbabbca713eb795d04c97abc01ee4983" +
+        "01010000000000000090d336b734c301" +
+        "ffffff00112233440000000002000c00" +
+        "44004f004d00410049004e0001000c00" +
+        "53004500520056004500520004001400" +
+        "64006f006d00610069006e002e006300" +
+        "6f006d00030022007300650072007600" +
+        "650072002e0064006f006d0061006900" +
+        "6e002e0063006f006d00000000000000" +
+        "0000"
+    ].pack("H*"))
+  end
+
+  it 'should generate a ntlm2_session' do
+    session = Net::NTLM::ntlm2_session(
+        {
+            :ntlm_hash => Net::NTLM::ntlm_hash(passwd),
+            :challenge => challenge
+        },
+        { :client_challenge => client_ch }
+    )
+    expect(session[0]).to eq(["ffffff001122334400000000000000000000000000000000"].pack("H*"))
+    expect(session[1]).to eq(["10d550832d12b2ccb79d5ad1f4eed3df82aca4c3681dd455"].pack("H*"))
+  end
+end