rex 2.0.5 → 2.0.7

data/lib/rex/proto/kerberos/model/kdc_response.rb

@@ -0,0 +1,141 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Proto
+    module Kerberos
+      module Model
+        # This class provides a representation of a Kerberos KDC-REQ (response) data
+        # definition
+        class KdcResponse < Element
+          # @!attribute pvno
+          #   @return [Fixnum] The protocol version number
+          attr_accessor :pvno
+          # @!attribute msg_type
+          #   @return [Fixnum] The type of a protocol message
+          attr_accessor :msg_type
+          # @!attribute crealm
+          #   @return [String] The realm part of the client's principal identifier
+          attr_accessor :crealm
+          # @!attribute cname
+          #   @return [Rex::Proto::Kerberos::Model::PrincipalName] The name part of the client's principal identifier
+          attr_accessor :cname
+          # @!attribute ticket
+          #   @return [Rex::Proto::Kerberos::Model::Ticket] The issued ticket
+          attr_accessor :ticket
+          # @!attribute enc_part
+          #   @return [Rex::Proto::Kerberos::Model::EncryptedData] The encrypted part of the response
+          attr_accessor :enc_part
+
+          # Decodes the Rex::Proto::Kerberos::Model::KdcResponse from an input
+          #
+          # @param input [String, OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [self] if decoding succeeds
+          # @raise [RuntimeError] if decoding doesn't succeed
+          def decode(input)
+            case input
+            when String
+              decode_string(input)
+            when OpenSSL::ASN1::ASN1Data
+              decode_asn1(input)
+            else
+              raise ::RuntimeError, 'Failed to decode KdcResponse, invalid input'
+            end
+
+            self
+          end
+
+          # Rex::Proto::Kerberos::Model::KdcResponse encoding isn't supported
+          #
+          # @raise [NotImplementedError]
+          def encode
+            raise ::NotImplementedError, 'KdcResponse encoding not supported'
+          end
+
+          private
+
+          # Decodes a Rex::Proto::Kerberos::Model::KdcResponse from an String
+          #
+          # @param input [String] the input to decode from
+          def decode_string(input)
+            asn1 = OpenSSL::ASN1.decode(input)
+
+            decode_asn1(asn1)
+          end
+
+          # Decodes a Rex::Proto::Kerberos::Model::KdcResponse
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @raise [RuntimeError] if decoding doesn't succeed
+          def decode_asn1(input)
+            input.value[0].value.each do |val|
+              case val.tag
+              when 0
+                self.pvno = decode_pvno(val)
+              when 1
+                self.msg_type = decode_msg_type(val)
+              when 3
+                self.crealm = decode_crealm(val)
+              when 4
+                self.cname = decode_cname(val)
+              when 5
+                self.ticket = decode_ticket(val)
+              when 6
+                self.enc_part = decode_enc_part(val)
+              else
+                raise ::RuntimeError, 'Failed to decode KDC-RESPONSE SEQUENCE'
+              end
+            end
+          end
+
+          # Decodes the pvno from an OpenSSL::ASN1::ASN1Data
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Fixnum]
+          def decode_pvno(input)
+            input.value[0].value.to_i
+          end
+
+          # Decodes the msg_type from an OpenSSL::ASN1::ASN1Data
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Fixnum]
+          def decode_msg_type(input)
+            input.value[0].value.to_i
+          end
+
+          # Decodes the crealm field
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [String]
+          def decode_crealm(input)
+            input.value[0].value
+          end
+
+          # Decodes the cname field
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Rex::Proto::Kerberos::Type::PrincipalName]
+          def decode_cname(input)
+            Rex::Proto::Kerberos::Model::PrincipalName.decode(input.value[0])
+          end
+
+          # Decodes the ticket field
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Rex::Proto::Kerberos::Type::Ticket]
+          def decode_ticket(input)
+            Rex::Proto::Kerberos::Model::Ticket.decode(input.value[0])
+          end
+
+          # Decodes the enc_part
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Rex::Proto::Kerberos::Model::EncryptedData]
+          def decode_enc_part(input)
+            Rex::Proto::Kerberos::Model::EncryptedData.decode(input.value[0])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rex/proto/kerberos/model/krb_error.rb

@@ -0,0 +1,219 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Proto
+    module Kerberos
+      module Model
+        # This class provides a representation of a Kerberos KRB-ERROR (response error)
+        # message definition.
+        class KrbError < Element
+          # @!attribute pvno
+          #   @return [Fixnum] The protocol version number
+          attr_accessor :pvno
+          # @!attribute msg_type
+          #   @return [Fixnum] The type of a protocol message
+          attr_accessor :msg_type
+          # @!attribute ctime
+          #   @return [Time] The current time of the client's host
+          attr_accessor :ctime
+          # @!attribute cusec
+          #   @return [Fixnum] The microseconds part of the client timestamp
+          attr_accessor :cusec
+          # @!attribute stime
+          #   @return [Time] The current time of the server
+          attr_accessor :stime
+          # @!attribute susec
+          #   @return [Fixnum] The microseconds part of the server timestamp
+          attr_accessor :susec
+          # @!attribute error_code
+          #   @return [Fixnum] The error request returned by kerberos or the server when a request fails
+          attr_accessor :error_code
+          # @!attribute crealm
+          #   @return [String] The realm part of the client's principal identifier
+          attr_accessor :crealm
+          # @!attribute cname
+          #   @return [Rex::Proto::Kerberos::Model::PrincipalName] The name part of the client's principal identifier
+          attr_accessor :cname
+          # @!attribute realm
+          #   @return [String] The realm part of the server's principal identifier
+          attr_accessor :realm
+          # @!attribute sname
+          #   @return [Rex::Proto::Kerberos::Model::PrincipalName] The name part of the server's identity
+          attr_accessor :sname
+          # @!attribute e_data
+          #   @return [String] additional data about the error (ASN.1 encoded data)
+          attr_accessor :e_data
+
+          # Decodes the Rex::Proto::Kerberos::Model::KrbError from an input
+          #
+          # @param input [String, OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [self] if decoding succeeds
+          # @raise [RuntimeError] if decoding doesn't succeed
+          def decode(input)
+            case input
+            when String
+              decode_string(input)
+            when OpenSSL::ASN1::ASN1Data
+              decode_asn1(input)
+            else
+              raise ::RuntimeError, 'Failed to decode KrbError, invalid input'
+            end
+
+            self
+          end
+
+          # Rex::Proto::Kerberos::Model::KrbError encoding isn't supported
+          #
+          # @raise [NotImplementedError]
+          def encode
+            raise ::NotImplementedError, 'KrbError encoding not supported'
+          end
+
+          private
+
+          # Decodes a Rex::Proto::Kerberos::Model::KrbError from an String
+          #
+          # @param input [String] the input to decode from
+          def decode_string(input)
+            asn1 = OpenSSL::ASN1.decode(input)
+
+            decode_asn1(asn1)
+          end
+
+          # Decodes a Rex::Proto::Kerberos::Model::KrbError
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @raise [RuntimeError] if decoding doesn't succeed
+          def decode_asn1(input)
+            input.value[0].value.each do |val|
+              case val.tag
+              when 0
+                self.pvno = decode_pvno(val)
+              when 1
+                self.msg_type = decode_msg_type(val)
+              when 2
+                self.ctime = decode_ctime(val)
+              when 3
+                self.cusec = decode_cusec(val)
+              when 4
+                self.stime = decode_stime(val)
+              when 5
+                self.susec = decode_susec(val)
+              when 6
+                self.error_code = decode_error_code(val)
+              when 7
+                self.crealm = decode_crealm(val)
+              when 8
+                self.cname = decode_cname(val)
+              when 9
+                self.realm = decode_realm(val)
+              when 10
+                self.sname = decode_sname(val)
+              when 12
+                self.e_data = decode_e_data(val)
+              else
+                raise ::RuntimeError, 'Failed to decode KRB-ERROR SEQUENCE'
+              end
+            end
+          end
+
+          # Decodes the pvno from an OpenSSL::ASN1::ASN1Data
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Fixnum]
+          def decode_pvno(input)
+            input.value[0].value.to_i
+          end
+
+          # Decodes the msg_type from an OpenSSL::ASN1::ASN1Data
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Fixnum]
+          def decode_msg_type(input)
+            input.value[0].value.to_i
+          end
+
+          # Decodes the ctime field
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Time]
+          def decode_ctime(input)
+            input.value[0].value
+          end
+
+          # Decodes the cusec field
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Fixnum]
+          def decode_cusec(input)
+            input.value[0].value
+          end
+
+          # Decodes the stime field
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Time]
+          def decode_stime(input)
+            input.value[0].value
+          end
+
+          # Decodes the susec field
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Fixnum]
+          def decode_susec(input)
+            input.value[0].value.to_i
+          end
+
+          # Decodes the error_code field
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Fixnum]
+          def decode_error_code(input)
+            input.value[0].value.to_i
+          end
+
+          # Decodes the crealm field
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [String]
+          def decode_crealm(input)
+            input.value[0].value
+          end
+
+          # Decodes the cname field
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Rex::Proto::Kerberos::Model::PrincipalName]
+          def decode_cname(input)
+            Rex::Proto::Kerberos::Model::PrincipalName.decode(input.value[0])
+          end
+
+          # Decodes the realm field
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [String]
+          def decode_realm(input)
+            input.value[0].value
+          end
+
+          # Decodes the sname field
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Rex::Proto::Kerberos::Model::PrincipalName]
+          def decode_sname(input)
+            Rex::Proto::Kerberos::Model::PrincipalName.decode(input.value[0])
+          end
+
+          # Decodes the e_data from an OpenSSL::ASN1::ASN1Data
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [String]
+          def decode_e_data(input)
+            input.value[0].value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rex/proto/kerberos/model/last_request.rb

@@ -0,0 +1,82 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Proto
+    module Kerberos
+      module Model
+        # This class provides a representation of request time
+        class LastRequest < Element
+
+          # @!attribute type
+          #   @return [Fixnum] The type of value
+          attr_accessor :type
+          # @!attribute value
+          #   @return [Time] the time of the last request
+          attr_accessor :value
+
+          # Decodes a Rex::Proto::Kerberos::Model::LastRequest
+          #
+          # @param input [String, OpenSSL::ASN1::Sequence] the input to decode from
+          # @return [self] if decoding succeeds
+          # @raise [RuntimeError] if decoding doesn't succeed
+          def decode(input)
+            case input
+            when String
+              decode_string(input)
+            when OpenSSL::ASN1::Sequence
+              decode_asn1(input)
+            else
+              raise ::RuntimeError, 'Failed to decode LastRequest, invalid input'
+            end
+
+            self
+          end
+
+          # Rex::Proto::Kerberos::Model::LastRequest encoding isn't supported
+          #
+          # @raise [NotImplementedError]
+          def encode
+            raise ::NotImplementedError, 'LastRequest encoding not supported'
+          end
+
+          private
+
+          # Decodes a Rex::Proto::Kerberos::Model::LastReque from an String
+          #
+          # @param input [String] the input to decode from
+          def decode_string(input)
+            asn1 = OpenSSL::ASN1.decode(input)
+
+            decode_asn1(asn1)
+          end
+
+          # Decodes a Rex::Proto::Kerberos::Model::EncryptionKey from an
+          # OpenSSL::ASN1::Sequence
+          #
+          # @param input [OpenSSL::ASN1::Sequence] the input to decode from
+          def decode_asn1(input)
+            seq_values = input.value
+            self.type = decode_type(seq_values[0])
+            self.value = decode_value(seq_values[1])
+          end
+
+          # Decodes the key_type from an OpenSSL::ASN1::ASN1Data
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Fixnum]
+          def decode_type(input)
+            input.value[0].value.to_i
+          end
+
+          # Decodes the value from an OpenSSL::ASN1::ASN1Data
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Time]
+          def decode_value(input)
+            input.value[0].value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rex/proto/kerberos/model/pre_auth_data.rb

@@ -0,0 +1,104 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Proto
+    module Kerberos
+      module Model
+        # This class provides a representation for Kerberos pre authenticated
+        # data
+        class PreAuthData < Element
+
+          # @!attribute type
+          #   @return [Fixnum] The padata type
+          attr_accessor :type
+          # @!attribute value
+          #   @return [String] The padata value
+          attr_accessor :value
+
+          # Decodes a Rex::Proto::Kerberos::Model::PreAuthData
+          #
+          # @param input [String, OpenSSL::ASN1::Sequence] the input to decode from
+          # @return [self] if decoding succeeds
+          # @raise [RuntimeError] if decoding doesn't succeed
+          def decode(input)
+            case input
+            when String
+              decode_string(input)
+            when OpenSSL::ASN1::Sequence
+              decode_asn1(input)
+            else
+              raise ::RuntimeError, 'Failed to decode PreAuthData, invalid input'
+            end
+
+            self
+          end
+
+          # Encodes a Rex::Proto::Kerberos::Model::PreAuthData into an ASN.1 String
+          #
+          # @return [String]
+          def encode
+            type_asn1 = OpenSSL::ASN1::ASN1Data.new([encode_type], 1, :CONTEXT_SPECIFIC)
+            value_asn1 = OpenSSL::ASN1::ASN1Data.new([encode_value], 2, :CONTEXT_SPECIFIC)
+            seq = OpenSSL::ASN1::Sequence.new([type_asn1, value_asn1])
+
+            seq.to_der
+          end
+
+          private
+
+          # Encodes the type
+          #
+          # @return [OpenSSL::ASN1::Integer]
+          def encode_type
+            int_bn = OpenSSL::BN.new(type.to_s)
+            int = OpenSSL::ASN1::Integer.new(int_bn)
+
+            int
+          end
+
+          # Encodes the value
+          #
+          # @return [OpenSSL::ASN1::OctetString]
+          def encode_value
+            OpenSSL::ASN1::OctetString.new(value)
+          end
+
+          # Decodes a Rex::Proto::Kerberos::Model::PreAuthData
+          #
+          # @param input [String] the input to decode from
+          def decode_string(input)
+            asn1 = OpenSSL::ASN1.decode(input)
+
+            decode_asn1(asn1)
+          end
+
+          # Decodes a Rex::Proto::Kerberos::Model::PreAuthData from an
+          # OpenSSL::ASN1::Sequence
+          #
+          # @param input [OpenSSL::ASN1::Sequence] the input to decode from
+          def decode_asn1(input)
+            seq_values = input.value
+            self.type  = decode_asn1_type(seq_values[0])
+            self.value = decode_asn1_value(seq_values[1])
+          end
+
+          # Decodes the type from an OpenSSL::ASN1::ASN1Data
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Fixnum]
+          def decode_asn1_type(input)
+            input.value[0].value.to_i
+          end
+
+          # Decodes the value from an OpenSSL::ASN1::ASN1Data
+          #
+          # @param input [OpenSSL::ASN1::ASN1Data] the input to decode from
+          # @return [Fixnum]
+          def decode_asn1_value(input)
+            input.value[0].value
+          end
+        end
+      end
+    end
+  end
+end