Fix all

Author: sdaubert

lib/packetgen/plugin/crypto.rb

@@ -100,7 +100,7 @@ def compute_iv_for_decrypting(salt, msg)
     # @param [String] salt salt to use
     # @return [void]
     def compute_iv_for_encrypting(iv, salt) # rubocop:disable Naming/MethodParameterName
-      real_iv = force_binary(salt) + force_binary(iv)
+      real_iv = salt.b + iv.b
       real_iv += [1].pack('N') if confidentiality_mode == 'ctr'
       @conf.iv = real_iv
     end

lib/packetgen/plugin/esp.rb

@@ -140,11 +140,11 @@ def initialize(options={})
     def read(str)
       return self if str.nil?
 
-      force_binary str
-      self[:spi].read str[0, 4]
-      self[:sn].read str[4, 4]
-      self[:tfc].read ''
-      self[:padding].read ''
+      str = str.b
+      self[:spi].read(str[0, 4])
+      self[:sn].read(str[4, 4])
+      self[:tfc].read('')
+      self[:padding].read('')
 
       read_icv_dependent_fields(str[8..-1])
       read_icv(str)
@@ -239,7 +239,7 @@ def read_icv(str)
     def get_auth_data(opt)
       ad = self[:spi].to_s
       if opt[:esn]
-        @esn = BinStruct::Int32.new(opt[:esn])
+        @esn = BinStruct::Int32.new(value: opt[:esn])
         ad << @esn.to_s if @conf.authenticated?
       end
       ad << self[:sn].to_s
@@ -273,12 +273,12 @@ def encrypt_set_pad_length
     def encrypt_set_padding(opt)
       if opt[:pad_length]
         self.pad_length = opt[:pad_length]
-        padding = force_binary(opt[:padding] || (1..self.pad_length).to_a.pack('C*'))
-        self[:padding].read padding
+        padding = opt[:padding] || (1..self.pad_length).to_a.pack('C*')
       else
-        padding = force_binary(opt[:padding] || (1..self.pad_length).to_a.pack('C*'))
-        self[:padding].read padding[0...self.pad_length]
+        padding = opt[:padding] || (1..self.pad_length).to_a.pack('C*')
+        padding = padding[0...self.pad_length]
       end
+      self[:padding].read(padding)
     end
 
     def generate_tfc(opt)
@@ -293,7 +293,7 @@ def generate_tfc(opt)
                    else
                      (tfc_size / 4) * 4
                    end
-        tfc = force_binary("\0" * tfc_size)
+        tfc = "\0".b * tfc_size
       end
       tfc
     end

lib/packetgen/plugin/ike/sk.rb

@@ -95,7 +95,7 @@ def decrypt!(cipher, options={})
         opt = { salt: '', parse: true }.merge!(options)
 
         set_crypto cipher, opt[:intmode]
-        iv = compute_iv_for_decrypting(force_binary(opt[:salt]), self[:content])
+        iv = compute_iv_for_decrypting(opt[:salt].b, self[:content])
 
         if authenticated?
           if @icv_length.zero?
@@ -163,7 +163,7 @@ def authenticate_if_needed(iv, icv=nil) # rubocop:disable Naming/MethodParameter
 
       def encrypt_body(iv, opt) # rubocop:disable Naming/MethodParameterName
         padding, pad_length = compute_padding(iv, opt)
-        msg = self[:body].to_s + padding + BinStruct::Int8.new(pad_length).to_s
+        msg = self[:body].to_s + padding.b + BinStruct::Int8.new(value: pad_length).to_s
         encrypted_msg = encipher(msg)
         @conf.final # message is already padded. No need for mode padding
         encrypted_msg
@@ -172,10 +172,10 @@ def encrypt_body(iv, opt) # rubocop:disable Naming/MethodParameterName
       def compute_padding(iv, opt) # rubocop:disable Naming/MethodParameterName
         if opt[:pad_length]
           pad_length = opt[:pad_length]
-          padding = force_binary(opt[:padding] || ([0] * pad_length).pack('C*'))
+          padding = opt[:padding] || ([0] * pad_length).pack('C*')
         else
           pad_length = compute_pad_length(iv)
-          padding = force_binary(opt[:padding] || ([0] * pad_length).pack('C*'))
+          padding = opt[:padding] || ([0] * pad_length).pack('C*')
           padding = padding[0, pad_length]
         end
         [padding, pad_length]

spec/esp_spec.rb

@@ -14,7 +14,7 @@ module Plugin
         end
 
         it 'in UDP packets' do
-          int32 = PacketGen::Types::Int32.new(1)
+          int32 = BinStruct::Int32.new(value: 1)
           expect(PacketGen::Header::UDP).to know_header(ESP).with(dport: 4500, sport: nil, body: int32.to_s)
           expect(PacketGen::Header::UDP).to know_header(ESP).with(sport: 4500, dport: nil, body: int32.to_s)
           int32.value = 0
@@ -117,8 +117,8 @@ module Plugin
           esp.body = 'body'
           esp.spi = 1
           esp.sn = 2
-          expected = [1, 2].pack('N2') + 'body' + "\x00" * 2
-          expect(esp.to_s).to eq(force_binary expected)
+          expected = [1, 2].pack('N2') + 'body'.b + "\x00".b * 2
+          expect(esp.to_s).to eq(expected)
         end
       end
 
@@ -127,7 +127,7 @@ module Plugin
           esp = ESP.new
           str = esp.inspect
           expect(str).to be_a(String)
-          (esp.fields - %i(body)).each do |attr|
+          (esp.attributes - %i(body)).each do |attr|
             expect(str).to include(attr.to_s)
           end
         end
@@ -196,7 +196,7 @@ module Plugin
             key = [key.to_s(16)].pack('H*')
             salt = [0xe6971987.to_s(16)].pack('H*')
             cipher = get_cipher('gcm', :encrypt, key)
-            iv = force_binary("\xD9\xD2\x1F\xCE\xDA\xE0Uj")
+            iv = "\xD9\xD2\x1F\xCE\xDA\xE0Uj".b
             black_pkt.esp.encrypt! cipher, iv, salt: salt, tfc: true, tfc_size: 1000
             expect(black_pkt.esp.to_s).to eq(esp_pkt.esp.to_s)
           end
@@ -215,7 +215,7 @@ module Plugin
             pkt.esp.decrypt!(cipher, salt: salt, esn: 0)
 
             cipher = get_cipher('gcm', :encrypt, key)
-            iv = force_binary("\xAB\r\xE6M\x84E\xF7V")
+            iv = "\xAB\r\xE6M\x84E\xF7V".b
             pkt.esp.encrypt! cipher, iv, salt: salt, esn: 0
             expect(pkt.to_s).to eq(expected_pkt_s)
           end
@@ -234,7 +234,7 @@ module Plugin
 
             black_pkt.esp.decrypt! get_cipher('gcm', :decrypt, key), salt: salt
             expect(black_pkt.esp.pad_length).to eq(2)
-            expect(black_pkt.esp.padding).to eq(force_binary("\xff\xff"))
+            expect(black_pkt.esp.padding).to eq("\xff\xff".b)
           end
 
           it 'encrypts a payload with given padding length' do
@@ -269,8 +269,8 @@ module Plugin
 
             black_pkt.esp.decrypt! get_cipher('gcm', :decrypt, key), salt: salt
             expect(black_pkt.esp.pad_length).to eq(15)
-            expect(black_pkt.esp.padding).to eq(force_binary("\xff" * 15))
-            expect(black_pkt.body[-9..-1]).to eq(force_binary("\xff" * 9))
+            expect(black_pkt.esp.padding).to eq("\xff".b * 15)
+            expect(black_pkt.body[-9..-1]).to eq("\xff".b * 9)
           end
         end
 
@@ -315,8 +315,8 @@ module Plugin
             cipher = get_cipher('gcm', :decrypt, key)
             expect(pkt.esp.decrypt!(cipher, salt: salt)).to be(true)
             expect(pkt.esp.tfc.length).to eq(916)
-            expect(pkt.esp.tfc).to eq(force_binary("\x00" * 916))
-            expect(pkt.esp.padding).to eq(force_binary("\x01\x02"))
+            expect(pkt.esp.tfc).to eq("\x00".b * 916)
+            expect(pkt.esp.padding).to eq("\x01\x02".b)
             expect(pkt.esp.body.to_s).to eq(red_pkt.ip.to_s)
           end
 
@@ -343,7 +343,7 @@ module Plugin
 
             cipher = get_cipher('gcm', :decrypt, key)
             expect(pkt.esp.decrypt!(cipher, salt: salt, parse: false)).to be(true)
-            expect(pkt.esp[:body]).to be_a(Types::String)
+            expect(pkt.esp[:body]).to be_a(BinStruct::String)
           end
 
           it 'returns false when ICV check failed' do
@@ -399,7 +399,7 @@ module Plugin
           pkt.body.read("\x00" * 16)
           str = pkt.to_s
           pkt2 = Packet.parse(str)
-          expect(pkt2.udp[:body]).to be_a(Types::String)
+          expect(pkt2.udp[:body]).to be_a(BinStruct::String)
         end
       end
     end

spec/ike/auth_spec.rb

@@ -70,8 +70,8 @@ class IKE
           it 'returns a binary string' do
             auth = Auth.new(next: 2, auth_method: 'PASSWORD', content: 'abcd')
             auth.calc_length
-            expected = "\x02\x00\x00\x0c\x0c\x00\x00\x00abcd"
-            expect(auth.to_s).to eq(force_binary expected)
+            expected = "\x02\x00\x00\x0c\x0c\x00\x00\x00abcd".b
+            expect(auth.to_s).to eq(expected)
           end
         end
 

spec/ike/cert_spec.rb

@@ -69,8 +69,8 @@ class IKE
           it 'returns a binary string' do
             cert = Cert.new(next: 2, encoding: 'X509_CERT_SIG', content: 'abcd')
             cert.calc_length
-            expected = "\x02\x00\x00\x09\x04abcd"
-            expect(cert.to_s).to eq(force_binary expected)
+            expected = "\x02\x00\x00\x09\x04abcd".b
+            expect(cert.to_s).to eq(expected)
           end
         end
 
@@ -79,7 +79,7 @@ class IKE
             cert = Cert.new
             str = cert.inspect
             expect(str).to be_a(String)
-            (cert.fields - %i(body)).each do |attr|
+            (cert.attributes - %i(body)).each do |attr|
                expect(str).to include(attr.to_s)
              end
           end

spec/ike/certreq_spec.rb

@@ -69,8 +69,8 @@ class IKE
           it 'returns a binary string' do
             certreq = CertReq.new(next: 2, encoding: 'X509_CERT_SIG', content: 'a' * 20)
             certreq.calc_length
-            expected = "\x02\x00\x00\x19\x04" + 'a' * 20
-            expect(certreq.to_s).to eq(force_binary expected)
+            expected = ("\x02\x00\x00\x19\x04" + 'a' * 20).b
+            expect(certreq.to_s).to eq(expected)
           end
         end
 
@@ -79,7 +79,7 @@ class IKE
             certreq = CertReq.new(content: 'a' * 20 + 'b' * 20)
             str = certreq.inspect
             expect(str).to be_a(String)
-            (certreq.fields - %i(body)).each do |attr|
+            (certreq.attributes - %i(body)).each do |attr|
               expect(str).to include(attr.to_s)
               if attr == :content
                 expect(str).to match(/^\s+hashes/)

spec/ike/id_spec.rb

@@ -79,14 +79,14 @@ class IKE
           it 'returns a binary string' do
             id = IDi.new(next: 2, type: 'IPV6_ADDR', content: IPAddr.new('8000::1').hton)
             id.calc_length
-            expected = "\x02\x00\x00\x18\x05\x00\x00\x00\x80" + "\0" * 14 + "\x01"
-            expect(id.to_s).to eq(force_binary expected)
+            expected = ("\x02\x00\x00\x18\x05\x00\x00\x00\x80" + "\0" * 14 + "\x01").b
+            expect(id.to_s).to eq(expected)
 
             name = OpenSSL::X509::Name.parse('/CN=toto/DC=tata').to_der
             id = IDi.new(next: 2, type: 'DER_ASN1_DN', content: name)
             id.calc_length
-            expected = "\x02\x00\x00\x2f\x09\x00\x00\x00" + name
-            expect(id.to_s).to eq(force_binary expected)
+            expected = ("\x02\x00\x00\x2f\x09\x00\x00\x00" + name).b
+            expect(id.to_s).to eq(expected)
           end
         end
 

spec/ike/ke_spec.rb

@@ -50,8 +50,8 @@ class IKE
           it 'returns a binary string' do
             ke = KE.new(next: 1, group: 'ECP256', content: 'abcdefghijkl')
             ke.calc_length
-            expected = "\x01\x00\x00\x14\x00\x13\x00\x00abcdefghijkl"
-            expect(ke.to_s).to eq(force_binary expected)
+            expected = "\x01\x00\x00\x14\x00\x13\x00\x00abcdefghijkl".b
+            expect(ke.to_s).to eq(expected)
           end
         end
 
@@ -60,7 +60,7 @@ class IKE
             ke = KE.new
             str = ke.inspect
             expect(str).to be_a(String)
-            (ke.fields - %i(body)).each do |attr|
+            (ke.attributes - %i(body)).each do |attr|
                expect(str).to include(attr.to_s)
              end
           end

spec/ike/nonce_spec.rb

@@ -45,8 +45,8 @@ class IKE
           it 'returns a binary string' do
             nonce = Nonce.new(next: 2, content: 'abcdefghijkl')
             nonce.calc_length
-            expected = "\x02\x00\x00\x10abcdefghijkl"
-            expect(nonce.to_s).to eq(force_binary expected)
+            expected = "\x02\x00\x00\x10abcdefghijkl".b
+            expect(nonce.to_s).to eq(expected)
           end
         end
 
@@ -55,7 +55,7 @@ class IKE
             nonce = Nonce.new
             str = nonce.inspect
             expect(str).to be_a(String)
-            (nonce.fields - %i(body)).each do |attr|
+            (nonce.attributes - %i(body)).each do |attr|
                expect(str).to include(attr.to_s)
              end
           end