packetgen-plugin-smb 0.6.3 → 0.7.0

data/lib/packetgen/plugin/smb/trans/request.rb

@@ -18,97 +18,98 @@ module PacketGen::Plugin
         #  The size, in 2-byte words, of the SMB command parameters. It should
         #  be +14 + setup_count+.
         #  @return [Integer]
-        define_field :word_count, PacketGen::Types::Int8, default: 14
+        define_attr :word_count, BinStruct::Int8, default: 14
         # @!attribute total_param_count
         #  The total number of transaction parameter bytes.
         #  @return [Integer]
-        define_field :total_param_count, PacketGen::Types::Int16le
+        define_attr :total_param_count, BinStruct::Int16le
         # @!attribute total_data_count
         #  The total number of transaction data bytes.
         #  @return [Integer]
-        define_field :total_data_count, PacketGen::Types::Int16le
+        define_attr :total_data_count, BinStruct::Int16le
         # @!attribute max_param_count
         #  The maximum number of parameter bytes that the client will accept
         #  in transaction response.
         #  @return [Integer]
-        define_field :max_param_count, PacketGen::Types::Int16le
+        define_attr :max_param_count, BinStruct::Int16le
         # @!attribute max_data_count
         #  The maximum number of data bytes that the client will accept
         #  in transaction response.
         #  @return [Integer]
-        define_field :max_data_count, PacketGen::Types::Int16le
+        define_attr :max_data_count, BinStruct::Int16le
         # @!attribute max_setup_count
         #  The maximum number of setup bytes that the client will accept
         #  in transaction response.
         #  @return [Integer]
-        define_field :max_setup_count, PacketGen::Types::Int8
+        define_attr :max_setup_count, BinStruct::Int8
         # @!attribute rsv1
         #  8-bit reserved field
         #  @return [Integer]
-        define_field :rsv1, PacketGen::Types::Int8, default: 0
+        define_attr :rsv1, BinStruct::Int8, default: 0
         # @!attribute flags
         #  16-bit flags
         #  @return [Integer]
-        define_field :flags, PacketGen::Types::Int16le
+        define_attr :flags, BinStruct::Int16le
         # @!attribute timeout
         #  32-bit timeout
         #  @return [Integer]
-        define_field :timeout, PacketGen::Types::Int32le
+        define_attr :timeout, BinStruct::Int32le
         # @!attribute rsv2
         #  16-bit reserved field
         #  @return [Integer]
-        define_field :rsv2, PacketGen::Types::Int16le, default: 0
+        define_attr :rsv2, BinStruct::Int16le, default: 0
         # @!attribute param_count
         #  16-bit number of transaction parameter bytes that the clients attempts to
         #  send to the server in this request.
         #  @return [Integer]
-        define_field :param_count, PacketGen::Types::Int16le
+        define_attr :param_count, BinStruct::Int16le
         # @!attribute param_offset
         #  16-bit offset (in bytes) from the start of the SMB header to the start of the
         #  transaction parameters.
         #  @return [Integer]
-        define_field :param_offset, PacketGen::Types::Int16le
+        define_attr :param_offset, BinStruct::Int16le
         # @!attribute data_count
         #  16-bit number of transaction data bytes that the clients sends to
         #  the server in this request.
         #  @return [Integer]
-        define_field :data_count, PacketGen::Types::Int16le
+        define_attr :data_count, BinStruct::Int16le
         # @!attribute data_offset
         #  16-bit offset (in bytes) from the start of the SMB header to the start
         #  of the data field.
         #  @return [Integer]
-        define_field :data_offset, PacketGen::Types::Int16le
+        define_attr :data_offset, BinStruct::Int16le
         # @!attribute setup_count
         #  8-bit number of setup words (ie 16-bit words) contained in {#setup} field.
-        define_field :setup_count, PacketGen::Types::Int8
+        define_attr :setup_count, BinStruct::Int8
         # @!attribute rsv3
         #  8-bit reserved field
         #  @return [Integer]
-        define_field :rsv3, PacketGen::Types::Int8
+        define_attr :rsv3, BinStruct::Int8
         # @!attribute setup
         #  Array of 2-byte words.
         #  @return [Array]
-        define_field :setup, PacketGen::Types::ArrayOfInt16le, builder: ->(h, t) { t.new(counter: h[:setup_count]) }
+        define_attr :setup, BinStruct::ArrayOfInt16le, builder: ->(h, t) { t.new(counter: h[:setup_count]) }
         # @!attribute byte_count
         #  @return [Integer]
-        define_field :byte_count, PacketGen::Types::Int16le
+        define_attr :byte_count, BinStruct::Int16le
         # @!attribute padname
         #  8-bit optional padding to align {#name} on a 2-byte boundary. Only present
         #  if {SMB#flags2_unicode?} is +true+.
         #  @return [Integer]
-        define_field :padname, PacketGen::Types::Int8, optional: ->(h) { h&.packet&.smb&.flags2_unicode? }
+        define_attr :padname, BinStruct::Int8, optional: ->(h) { h&.packet&.smb&.flags2_unicode? } # rubocop:disable Style/SafeNavigationChainLength
         # @!attribute name
         #  Pathname of the mailslot or named pipe.
         #  @return [String]
-        define_field :name, SMB::String, builder: ->(h, t) { t.new(unicode: !h.packet || h.packet.smb.flags2_unicode?) }
+        define_attr :name, SMB::String, builder: ->(h, t) { t.new(unicode: !h.packet || h.packet.smb.flags2_unicode?) }
         # @!attribute pad1
         #  Padding to align {#body} on 4-byte boundary.
         #  @return [String]
-        define_field :pad1, PacketGen::Types::String, default: "\0" * 4,
-                     builder: ->(h, t) { t.new(length_from: -> { h.data_offset - SMB.new.sz - (h.offset_of(:name) + h[:name].sz) }) }
+        define_attr :pad1, BinStruct::String,
+                    default: "\0" * 4,
+                    builder: ->(h, t) { t.new(length_from: -> { h.data_offset - SMB.new.sz - (h.offset_of(:name) + h[:name].sz) }) }
         # @!attribute body
         #  @return [String]
-        define_field :body, PacketGen::Types::String
+        define_attr :body, BinStruct::String
 
         # Give protocol name for this class
         # @return [String]

data/lib/packetgen/plugin/smb/trans/response.rb

@@ -18,70 +18,71 @@ module PacketGen::Plugin
         #  The size, in 2-byte words, of the SMB command parameters. It should
         #  be +14 + setup_count+.
         #  @return [Integer]
-        define_field :word_count, PacketGen::Types::Int8, default: 10
+        define_attr :word_count, BinStruct::Int8, default: 10
         # @!attribute total_param_count
         #  The total number of transaction parameter bytes.
         #  @return [Integer]
-        define_field :total_param_count, PacketGen::Types::Int16le
+        define_attr :total_param_count, BinStruct::Int16le
         # @!attribute total_data_count
         #  The total number of transaction data bytes.
         #  @return [Integer]
-        define_field :total_data_count, PacketGen::Types::Int16le
+        define_attr :total_data_count, BinStruct::Int16le
         # @!attribute rsv1
         #  16-bit reserved field
         #  @return [Integer]
-        define_field :rsv1, PacketGen::Types::Int16le, default: 0
+        define_attr :rsv1, BinStruct::Int16le, default: 0
         # @!attribute param_count
         #  16-bit number of transaction parameter bytes sent in this response.
         #  @return [Integer]
-        define_field :param_count, PacketGen::Types::Int16le
+        define_attr :param_count, BinStruct::Int16le
         # @!attribute param_offset
         #  16-bit offset (in bytes) from the start of the SMB header to the start of the
         #  transaction parameters.
         #  @return [Integer]
-        define_field :param_offset, PacketGen::Types::Int16le
+        define_attr :param_offset, BinStruct::Int16le
         # @!attribute param_displacement
         #  16-bit offset (in bytes) relative to all of the transaction
         #  parameter bytes in this transaction response at which this block of
         #  parameter bytes SHOULD be placed.
         #  @return [Integer]
-        define_field :param_displacement, PacketGen::Types::Int16le
+        define_attr :param_displacement, BinStruct::Int16le
         # @!attribute data_count
         #  16-bit number of transaction data bytes sent in this response.
         #  @return [Integer]
-        define_field :data_count, PacketGen::Types::Int16le
+        define_attr :data_count, BinStruct::Int16le
         # @!attribute data_offset
         #  16-bit offset (in bytes) from the start of the SMB header to the start
         #  of the data field.
         #  @return [Integer]
-        define_field :data_offset, PacketGen::Types::Int16le
+        define_attr :data_offset, BinStruct::Int16le
         # @!attribute data_displacement
         #  16-bit offset (in bytes) relative to all of the transaction data bytes in
         #  this transaction response at which this block of data bytes SHOULD be placed.
         #  @return [Integer]
-        define_field :data_displacement, PacketGen::Types::Int16le
+        define_attr :data_displacement, BinStruct::Int16le
         # @!attribute setup_count
         #  8-bit number of setup words (ie 16-bit words) contained in {#setup} field.
-        define_field :setup_count, PacketGen::Types::Int8
+        define_attr :setup_count, BinStruct::Int8
         # @!attribute rsv3
         #  8-bit reserved field
         #  @return [Integer]
-        define_field :rsv2, PacketGen::Types::Int8
+        define_attr :rsv2, BinStruct::Int8
         # @!attribute setup
         #  Array of 2-byte words.
         #  @return [ArrayPacketGen::]
-        define_field :setup, PacketGen::Types::ArrayOfInt16le, builder: ->(h, t) { t.new(counter: h[:setup_count]) }
+        define_attr :setup, BinStruct::ArrayOfInt16le, builder: ->(h, t) { t.new(counter: h[:setup_count]) }
         # @!attribute byte_count
         #  @return [Integer]
-        define_field :byte_count, PacketGen::Types::Int16le
+        define_attr :byte_count, BinStruct::Int16le
         # @!attribute pad1
         #  Padding before {#body} to align it on 32-bit boundary
         #  @return [Integer]
-        define_field :pad1, PacketGen::Types::String, default: "\0" * 4,
-                     builder: ->(h, t) { t.new(length_from: -> { h.data_offset - SMB.new.sz - (h.offset_of(:byte_count) + h[:byte_count].sz) }) }
+        define_attr :pad1, BinStruct::String,
+                    default: "\0" * 4,
+                    builder: ->(h, t) { t.new(length_from: -> { h.data_offset - SMB.new.sz - (h.offset_of(:byte_count) + h[:byte_count].sz) }) }
         # @!attribute body
         #  @return [String]
-        define_field :body, PacketGen::Types::String
+        define_attr :body, BinStruct::String
 
         # Give protocol name for this class
         # @return [String]

data/lib/packetgen/plugin/smb.rb

@@ -28,64 +28,22 @@ module PacketGen::Plugin
       'nt_trans' => 0xa0,
       'nt_create_and_x' => 0xa2
     }.freeze
+
     # SMB marker, on start of header
-    MARKER = PacketGen.force_binary("\xffSMB")
+    MARKER = "\xffSMB".b.freeze
 
     # @!attribute protocol
     #  This field must contain {MARKER SMB marker}
     #  @return [String]
-    define_field :protocol, PacketGen::Types::String, static_length: 4, default: MARKER
+    define_attr :protocol, BinStruct::String, static_length: 4, default: MARKER
     # @!attribute command
     #  8-bit SMB command
     #  @return [Integer]
-    define_field :command, PacketGen::Types::Int8Enum, enum: COMMANDS
+    define_attr :command, BinStruct::Int8Enum, enum: COMMANDS
     # @!attribute status
     #  32-bit status field. Used to communicate errors from server to client.
     #  @return [Integer]
-    define_field :status, PacketGen::Types::Int32le
-    # @!attribute flags
-    #  8-bit flags field
-    #  @return [Integer]
-    define_field :flags, PacketGen::Types::Int8
-    # @!attribute flags2
-    #  16-bit flags field
-    #  @return [Integer]
-    define_field :flags2, PacketGen::Types::Int16le
-    # @!attribute pid_high
-    #  16 high order bits of a process identifier (PID)
-    #  @return [Integer]
-    define_field :pid_high, PacketGen::Types::Int16le
-    # @!attribute sec_features
-    #  64-bit field. May be:
-    #  * a 64-bit cryptographic message signature if signature was negotiated,
-    #  * a SecurityFeatures structure, only over connectionless transport,
-    #    composed of:
-    #    * a 16-bit sequence number,
-    #    * a 16-bit connection identifier (CID),
-    #    * a 32-bit key to validate message,
-    #  * a reserved field in all others cases.
-    #  @return [Integer]
-    define_field :sec_features, PacketGen::Types::Int64le
-    # @!attribute reserved
-    #  16-bit reserved field
-    #  @return [Integer]
-    define_field :reserved, PacketGen::Types::Int16le
-    # @!attribute tid
-    #  16-bit tree identifier (TID)
-    define_field :tid, PacketGen::Types::Int16le
-    # @!attribute pid
-    #  16 low order bits of a process identifier (PID)
-    #  @return [Integer]
-    define_field :pid, PacketGen::Types::Int16le
-    # @!attribute uid
-    #  16-bit user identifier (UID)
-    define_field :uid, PacketGen::Types::Int16le
-    # @!attribute mid
-    #  16-bit multiplex identifier (MID)
-    define_field :mid, PacketGen::Types::Int16le
-    # @!attribute body
-    #  @return [String]
-    define_field :body, PacketGen::Types::String
+    define_attr :status, BinStruct::Int32le
     # @!attribute flags_reply?
     #  When set, the message is a reply from server to client.
     #  @return [Boolean]
@@ -110,9 +68,9 @@ module PacketGen::Plugin
     #  When set in SMB_COM_NEGOTIATE response, the server supports
     #  SMB_COM_LOCK_AND_READ and SNB_COM_WRITE_AND_UNLOCK commands.
     #  @return [Boolean]
-    define_bit_fields_on :flags, :flags_reply, :flags_opbatch, :flags_oplock,
-                         :flags_canon_paths, :flags_case_insensitive,
-                         :flags_reserved, :flags_buf_avail, :flags_locknread
+    define_bit_attr :flags, flags_reply: 1, flags_opbatch: 1, flags_oplock: 1,
+                            flags_canon_paths: 1, flags_case_insensitive: 1,
+                            flags_reserved: 1, flags_buf_avail: 1, flags_locknread: 1
     # @!attribute flags2_unicode?
     #  If set, each field that contains a string in this message is encoded
     #  as UTF-16.
@@ -151,12 +109,47 @@ module PacketGen::Plugin
     # @!attribute flags2_long_names?
     #  If unset, file names must adhere to the 8.3 naming convention.
     #  @return [Boolean]
-    define_bit_fields_on :flags2, :flags2_unicode, :flags2_ntstatus,
-                         :flags2_paging_io, :flags2_dfs, :flags2_extended_security,
-                         :flags2_reparse_path, :flags2_reserved, 3,
-                         :flags2_is_long_name, :flags2_rsv,
-                         :flags2_security_signature_required, :flags2_compresses,
-                         :flags2_signature, :flags2_eas, :flags2_long_names
+    define_bit_attr :flags2, endian: :little, flags2_unicode: 1, flags2_ntstatus: 1,
+                             flags2_paging_io: 1, flags2_dfs: 1, flags2_extended_security: 1,
+                             flags2_reparse_path: 1, flags2_reserved: 3,
+                             flags2_is_long_name: 1, flags2_rsv: 1,
+                             flags2_security_signature_required: 1, flags2_compresses: 1,
+                             flags2_signature: 1, flags2_eas: 1, flags2_long_names: 1
+    # @!attribute pid_high
+    #  16 high order bits of a process identifier (PID)
+    #  @return [Integer]
+    define_attr :pid_high, BinStruct::Int16le
+    # @!attribute sec_features
+    #  64-bit field. May be:
+    #  * a 64-bit cryptographic message signature if signature was negotiated,
+    #  * a SecurityFeatures structure, only over connectionless transport,
+    #    composed of:
+    #    * a 16-bit sequence number,
+    #    * a 16-bit connection identifier (CID),
+    #    * a 32-bit key to validate message,
+    #  * a reserved field in all others cases.
+    #  @return [Integer]
+    define_attr :sec_features, BinStruct::Int64le
+    # @!attribute reserved
+    #  16-bit reserved field
+    #  @return [Integer]
+    define_attr :reserved, BinStruct::Int16le
+    # @!attribute tid
+    #  16-bit tree identifier (TID)
+    define_attr :tid, BinStruct::Int16le
+    # @!attribute pid
+    #  16 low order bits of a process identifier (PID)
+    #  @return [Integer]
+    define_attr :pid, BinStruct::Int16le
+    # @!attribute uid
+    #  16-bit user identifier (UID)
+    define_attr :uid, BinStruct::Int16le
+    # @!attribute mid
+    #  16-bit multiplex identifier (MID)
+    define_attr :mid, BinStruct::Int16le
+    # @!attribute body
+    #  @return [String]
+    define_attr :body, BinStruct::String
 
     # Helper to bind a SMB command to {SMB} header.
     # @param [String] command name
@@ -166,7 +159,7 @@ module PacketGen::Plugin
       krequest = self.const_get("#{contantized}::Request")
       kresponse = self.const_get("#{contantized}::Response")
       PacketGen::Header.add_class krequest
-      self.bind krequest, command: SMB::COMMANDS[command], flags: ->(v) { v.nil? ? 0 : (v & 0x80).zero? }
+      self.bind krequest, command: SMB::COMMANDS[command], flags: ->(v) { v.nil? ? 0 : v.nobits?(0x80) }
       PacketGen::Header.add_class kresponse
       self.bind kresponse, command: SMB::COMMANDS[command], flags: ->(v) { v.nil? ? 0 : (v & 0x80 == 0x80) }
     end
@@ -182,16 +175,13 @@ module PacketGen::Plugin
       super do |attr|
         case attr
         when :flags, :flags2
-          value = bits_on(attr).reject { |_, v| v > 1 }
-                               .keys
-                               .select { |b| send("#{b}?") }
+          value = bits_on(attr).select { |b| respond_to?("#{b}?") && send("#{b}?") }
                                .map(&:to_s)
                                .join(',')
                                .gsub!(/#{attr}_/, '')
           value = '%-16s (0x%02x)' % [value, self[attr].to_i]
           str = PacketGen::Inspect.shift_level
-          str << PacketGen::Inspect::FMT_ATTR % [self[attr].class.to_s.sub(/.*::/, ''),
-                                                 attr, value]
+          str << (PacketGen::Inspect::FMT_ATTR % [self[attr].type_name, attr, value])
         end
       end
     end

data/lib/packetgen/plugin/smb2/base.rb

@@ -17,12 +17,12 @@ module PacketGen::Plugin
       # @param [Symbol] name name of padding field
       # @return [void]
       def self.define_smb2_pad_field(name)
-        prev_field = self.fields.last
+        prev_field = self.attributes.last
         lf = lambda do |hdr|
-          (8 - (hdr.offset_of(prev_field) + hdr[prev_field].sz) % 8) % 8
+          (8 - ((hdr.offset_of(prev_field) + hdr[prev_field].sz) % 8)) % 8
         end
-        define_field name, PacketGen::Types::String, default: SMB2::MAX_PADDING,
-                     builder: ->(h, t) { t.new(length_from: -> { lf[h] }) }
+        define_attr name, BinStruct::String, default: SMB2::MAX_PADDING,
+                                             builder: ->(h, t) { t.new(length_from: -> { lf[h] }) }
       end
     end
   end

data/lib/packetgen/plugin/smb2/error.rb

@@ -24,26 +24,26 @@ module PacketGen::Plugin
       # @!attribute structure_size
       #  16-bit error response structure. Should be 9.
       #  @return [Integer]
-      define_field :structure_size, PacketGen::Types::Int16le, default: 9
+      define_attr :structure_size, BinStruct::Int16le, default: 9
       # !@attribute context_count
       #  Only for SMB3 dialect. If non zero, this is the number of element
       #  in {#data}, formatted as a variable length array.
       #  @return [Integer]
-      define_field :context_count, PacketGen::Types::Int8
+      define_attr :context_count, BinStruct::Int8
       # !@attribute reserved
       #  8-bit reserved value
       #  @return [Integer]
-      define_field :reserved, PacketGen::Types::Int8
+      define_attr :reserved, BinStruct::Int8
       # @!attribute byte_count
       #  32-bit value indicating the number of bytes contained in {#data}
       #  @return [Integer]
-      define_field :byte_count, PacketGen::Types::Int32le
+      define_attr :byte_count, BinStruct::Int32le
       # @!attribute data
       #  Variable-length data field.
       #  @return [String]
-      define_field :data, PacketGen::Types::String
+      define_attr :data, BinStruct::String
     end
   end
   PacketGen::Header.add_class SMB2::ErrorResponse
-  SMB2.bind SMB2::ErrorResponse, status: ->(v) { v.positive? }
+  SMB2.bind SMB2::ErrorResponse, status: lambda(&:positive?)
 end

data/lib/packetgen/plugin/smb2/guid.rb

@@ -21,25 +21,25 @@ module PacketGen::Plugin
     #   |                                                               |
     #   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     # @author Sylvain Daubert
-    class GUID < PacketGen::Types::Fields
-      include PacketGen::Types::Fieldable
+    class GUID < BinStruct::Struct
+      include BinStruct::Structable
 
       # @!attribute data1
       #  32-bit little-endian data1
       #  @return [Integer]
-      define_field :data1, PacketGen::Types::Int32le
+      define_attr :data1, BinStruct::Int32le
       # @!attribute data2
       #  16-bit little-endian data2
       #  @return [Integer]
-      define_field :data2, PacketGen::Types::Int16le
+      define_attr :data2, BinStruct::Int16le
       # @!attribute data3
       #  16-bit little-endian data3
       #  @return [Integer]
-      define_field :data3, PacketGen::Types::Int16le
+      define_attr :data3, BinStruct::Int16le
       # @!attribute data4
       #  64-bit big-endian data4
       #  @return [Integer]
-      define_field :data4, PacketGen::Types::Int64
+      define_attr :data4, BinStruct::Int64
 
       # Get a human-readable GUID, as specified in RFC 4122
       #   guid.to_human  # => "7aedb437-01b9-41d4-a5f7-9e6c06e16c8a"
@@ -47,7 +47,7 @@ module PacketGen::Plugin
       def to_human
         data4p1 = data4 >> 48
         data4p2 = data4 & 0xffff_ffff_ffff
-        "%08x-%04x-%04x-%04x-%012x" % [data1, data2, data3, data4p1, data4p2]
+        '%08x-%04x-%04x-%04x-%012x' % [data1, data2, data3, data4p1, data4p2] # rubocop:disable Style/FormatStringToken
       end
 
       # Set GUID from a human-readable string
@@ -56,13 +56,13 @@ module PacketGen::Plugin
       def from_human(guid)
         return self if guid.nil? || guid.empty?
 
-        values = guid.split('-')
+        values = guid.split('-').map { |v| v.to_i(16) }
         return self if values.size != 5
 
-        self.data1 = values[0].to_i(16)
-        self.data2 = values[1].to_i(16)
-        self.data3 = values[2].to_i(16)
-        self.data4 = values[3].to_i(16) << 48 | values[4].to_i(16)
+        self.data1 = values[0]
+        self.data2 = values[1]
+        self.data3 = values[2]
+        self.data4 = (values[3] << 48) | values[4]
         self
       end
     end

data/lib/packetgen/plugin/smb2/negotiate/context.rb

@@ -21,7 +21,7 @@ module PacketGen::Plugin
       #   |                              ...                              |
       #   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       # @author Sylvain Daubert
-      class Context < PacketGen::Types::Fields
+      class Context < BinStruct::Struct
         # Known types
         TYPES = {
           'PREAUTH_INTEGRITY_CAP' => 1,
@@ -31,23 +31,23 @@ module PacketGen::Plugin
         # @!attribute type
         #  16-bit context type
         #  @return [Integer]
-        define_field :type, PacketGen::Types::Int16leEnum, enum: TYPES
+        define_attr :type, BinStruct::Int16leEnum, enum: TYPES
         # @!attribute data_length
         #  16-bit data length
         #  @return [Integer]
-        define_field :data_length, PacketGen::Types::Int16le
+        define_attr :data_length, BinStruct::Int16le
         # @!attribute reserved
         #  32-bit reserved field
         #  @return [Integer]
-        define_field :reserved, PacketGen::Types::Int32le
+        define_attr :reserved, BinStruct::Int32le
         # @!attribute data
         #  context data
         #  @return [String]
-        define_field :data, PacketGen::Types::String, builder: ->(h, t) { t.new(length_from: h[:data_length]) }
+        define_attr :data, BinStruct::String, builder: ->(h, t) { t.new(length_from: h[:data_length]) }
         # @!attribute pad
         #  Padding to align next context on a 8-byte offset
         #  @return [String]
-        define_field :pad, PacketGen::Types::String, builder: ->(h, t) { t.new(length_from: -> { 8 - (h.offset_of(:data) + h.data_length) % 8 }) }
+        define_attr :pad, BinStruct::String, builder: ->(h, t) { t.new(length_from: -> { 8 - ((h.offset_of(:data) + h.data_length) % 8) }) }
 
         # @private
         alias old_read read
@@ -74,45 +74,45 @@ module PacketGen::Plugin
 
       # Specialized {Context} for PREAUTH_INTEGRITY_CAP type.
       class PreauthIntegrityCap < Context
-        remove_field :data
+        remove_attr :data
         # @!attribute hash_alg_count
         #  16-bit number of hash algorithm in {#hash_alg}
         #  @return [Integer]
-        define_field_before :pad, :hash_alg_count, PacketGen::Types::Int16le
+        define_attr_before :pad, :hash_alg_count, BinStruct::Int16le
         # @!attribute salt_length
         #  16-bit length of {#salt} field, in bytes.
         #  @return [Integer]
-        define_field_before :pad, :salt_length, PacketGen::Types::Int16le
+        define_attr_before :pad, :salt_length, BinStruct::Int16le
         # @!attribute hash_alg
         #  Array of 16-bit integer IDs specifying the supported preauthentication
         #  hash algorithms
-        #  @return [PacketGen::Types::ArrayOfInt16le]
-        define_field_before :pad, :hash_alg, PacketGen::Types::ArrayOfInt16le, builder: ->(h, t) { t.new(counter: h[:hash_alg_count]) }
+        #  @return [BinStruct::ArrayOfInt16le]
+        define_attr_before :pad, :hash_alg, BinStruct::ArrayOfInt16le, builder: ->(h, t) { t.new(counter: h[:hash_alg_count]) }
         # @!attribute salt
         #  Salt value for hash
         #  @return [String]
-        define_field_before :pad, :salt, PacketGen::Types::String, builder: ->(h, t) { t.new(length_from: h[:salt_length]) }
-        update_field :pad, builder: ->(h, t) { t.new(length_from: -> { (8 - (h.offset_of(:salt) + h.salt_length) % 8) % 8 }) }
+        define_attr_before :pad, :salt, BinStruct::String, builder: ->(h, t) { t.new(length_from: h[:salt_length]) }
+        update_attr :pad, builder: ->(h, t) { t.new(length_from: -> { (8 - ((h.offset_of(:salt) + h.salt_length) % 8)) }) }
       end
 
       # Specialized {Context} for ENCRYPTION_CAP type.
       class EncryptionCap < Context
-        remove_field :data
+        remove_attr :data
         # @!attribute cipher_count
         #  16-bit number of cipher algorithm in {#ciphers}
         #  @return [Integer]
-        define_field_before :pad, :cipher_count, PacketGen::Types::Int16le
+        define_attr_before :pad, :cipher_count, BinStruct::Int16le
         # @!attribute ciphers
         #  Array of 16-bit integer IDs specifying the supported encryption
         #  algorithms
-        #  @return [PacketGen::Types::ArrayOfInt16le]
-        define_field_before :pad, :ciphers, PacketGen::Types::ArrayOfInt16le, builder: ->(h, t) { t.new(counter: h[:cipher_count]) }
-        update_field :pad, builder: ->(h, t) { t.new(length_from: -> { (8 - (h.offset_of(:cipher_count) + h[:cipher_count].sz) % 8) % 8 }) }
+        #  @return [BinStruct::ArrayOfInt16le]
+        define_attr_before :pad, :ciphers, BinStruct::ArrayOfInt16le, builder: ->(h, t) { t.new(counter: h[:cipher_count]) }
+        update_attr :pad, builder: ->(h, t) { t.new(length_from: -> { (8 - ((h.offset_of(:cipher_count) + h[:cipher_count].sz) % 8)) % 8 }) }
       end
 
       # Array of {Context}
       # @author Sylvain Daubert
-      class ArrayOfContext < PacketGen::Types::Array
+      class ArrayOfContext < BinStruct::Array
         set_of Context
 
         private