net-smtp-ntlm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ce835096d258af930fc3a8bbea0f30751c91c734cb900c7dea399f17c23230b3
+  data.tar.gz: 7bc58f9680c6b5c5ad2995fcf793f99be819b1b17d7b569f3d968aaf29f08693
+SHA512:
+  metadata.gz: a3587cced6b74a95f84ac44a9653d4dcd69a4a743278ba16e707738aae875a48f70f62994b29e4da689779f16e8e5c55800aa887d65c66b7371221371f9e3639
+  data.tar.gz: d299b436f46e4afb903e286295a709c1ad776794a0c77fe66bf827b1a7e1aa207abfa50b911c90d0c220a28d2053905cfd25e9ee781fbc378fd3a3fc08dd0422

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 0.0.1
+
+- Базовая версия с поддержкой NTLM для SMTP

data/README.md

@@ -0,0 +1,27 @@
+# Net::SMTP::NTLM
+
+Add-on for [net-smtp](https://github.com/ruby/net-smtp/) gem to add NTLM support.
+
+Based on [ruby-ntlm](https://github.com/macks/ruby-ntlm) gem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'net-smtp-ntlm'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install net-smtp-ntlm
+
+## Usage
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/net-smtp.

data/lib/net/smtp/ntlm/auth_ntlm.rb

@@ -0,0 +1,16 @@
+module Net::SMTP::NTLM
+  class AuthNtlm < Net::SMTP::Authenticator
+    auth_type :ntlm
+
+    def auth(user, secret)
+      if user.index('\\')
+        domain, user = user.split('\\', 2)
+      else
+        domain = ''
+      end
+
+      challenge = continue("AUTH NTLM #{Net::SMTP::NTLM.negotiate.to_base64}")
+      finish(Net::SMTP::NTLM.authenticate(challenge.unpack('m').first, user, domain, secret).to_base64)
+    end
+  end
+end

data/lib/net/smtp/ntlm/message.rb

@@ -0,0 +1,365 @@
+require 'net/smtp/ntlm/util'
+  
+module Net::SMTP::NTLM
+  class Message
+
+    include Net::SMTP::NTLM::Util
+
+    SSP_SIGNATURE  = "NTLMSSP\0"
+
+    # [MS-NLMP] 2.2.2.5
+    FLAGS = {
+      :NEGOTIATE_UNICODE           => 0x00000001,  # Unicode character set encoding
+      :NEGOTIATE_OEM               => 0x00000002,  # OEM character set encoding
+      :REQUEST_TARGET              => 0x00000004,  # TargetName is supplied in challenge message
+      :UNUSED10                    => 0x00000008,
+      :NEGOTIATE_SIGN              => 0x00000010,  # Session key negotiation for message signatures
+      :NEGOTIATE_SEAL              => 0x00000020,  # Session key negotiation for message confidentiality
+      :NEGOTIATE_DATAGRAM          => 0x00000040,  # Connectionless authentication
+      :NEGOTIATE_LM_KEY            => 0x00000080,  # LAN Manager session key computation
+      :UNUSED9                     => 0x00000100,
+      :NEGOTIATE_NTLM              => 0x00000200,  # NTLM v1 protocol
+      :UNUSED8                     => 0x00000400,
+      :ANONYMOUS                   => 0x00000800,  # Anonymous connection
+      :OEM_DOMAIN_SUPPLIED         => 0x00001000,  # Domain field is present
+      :OEM_WORKSTATION_SUPPLIED    => 0x00002000,  # Workstations field is present
+      :UNUSED7                     => 0x00004000,
+      :NEGOTIATE_ALWAYS_SIGN       => 0x00008000,
+      :TARGET_TYPE_DOMAIN          => 0x00010000,  # TargetName is domain name
+      :TARGET_TYPE_SERVER          => 0x00020000,  # TargetName is server name
+      :UNUSED6                     => 0x00040000,
+      :NEGOTIATE_EXTENDED_SECURITY => 0x00080000,  # NTLM v2 session security
+      :NEGOTIATE_IDENTIFY          => 0x00100000,  # Requests identify level token
+      :UNUSED5                     => 0x00200000,
+      :REQUEST_NON_NT_SESSION_KEY  => 0x00400000,  # LM session key is used
+      :NEGOTIATE_TARGET_INFO       => 0x00800000,  # Requests TargetInfo
+      :UNUSED4                     => 0x01000000,
+      :NEGOTIATE_VERSION           => 0x02000000,  # Version field is present
+      :UNUSED3                     => 0x04000000,
+      :UNUSED2                     => 0x08000000,
+      :UNUSED1                     => 0x10000000,
+      :NEGOTIATE_128               => 0x20000000,  # 128bit encryption
+      :NEGOTIATE_KEY_EXCH          => 0x40000000,  # Explicit key exchange
+      :NEGOTIATE_56                => 0x80000000,  # 56bit encryption
+    }
+
+    # [MS-NLMP] 2.2.2.1
+    AV_PAIRS = {
+      :AV_EOL               => 0,
+      :AV_NB_COMPUTER_NAME  => 1,
+      :AV_NB_DOMAIN_NAME    => 2,
+      :AV_DNS_COMPUTER_NAME => 3,
+      :AV_DNS_DOMAIN_NAME   => 4,
+      :AV_DNS_TREE_NAME     => 5,
+      :AV_FLAGS             => 6,
+      :AV_TIMESTAMP         => 7,
+      :AV_RESTRICTIONS      => 8,
+      :AV_TARGET_NAME       => 9,
+      :AV_CHANNEL_BINDINGS  => 10,
+    }
+    AV_PAIR_NAMES = AV_PAIRS.invert
+
+    FLAGS.each do |name, val|
+      const_set(name, val)
+    end
+
+    AV_PAIRS.each do |name, val|
+      const_set(name, val)
+    end
+
+    class ParseError < StandardError; end
+
+    attr_accessor :flag
+
+
+    def self.parse(*args)
+      new.parse(*args)
+    end
+
+    def initialize(args = {})
+      @buffer      = ''
+      @offset      = 0
+      @flag        = args[:flag] || self.class::DEFAULT_FLAGS
+      @domain      = nil
+      @workstation = nil
+      @version     = nil
+      @target_info = nil
+      @session_key = nil
+      @mic         = nil
+
+      self.class::ATTRIBUTES.each do |key|
+        instance_variable_set("@#{key}", args[key]) if args[key]
+      end
+    end
+
+    def to_s
+      serialize
+    end
+
+    def serialize_to_base64
+      [serialize].pack('m').delete("\r\n")
+    end
+
+    alias to_base64 serialize_to_base64
+
+    def has_flag?(symbol)
+      (@flag & FLAGS[symbol]) != 0
+    end
+
+    def set(symbol)
+      @flag |= FLAGS[symbol]
+    end
+
+    def clear(symbol)
+      @flag &= ~FLAGS[symbol]
+    end
+
+    def unicode?
+      has_flag?(:NEGOTIATE_UNICODE)
+    end
+
+    def inspect_flags
+      flags = []
+      FLAGS.sort_by(&:last).each do |name, val|
+        flags << name if (@flag & val).nonzero?
+      end
+      "[#{flags.join(', ')}]"
+    end
+
+    def inspect
+      variables = (instance_variables.map(&:to_sym) - [:@offset, :@buffer, :@flag]).sort.map {|name| "#{name}=#{instance_variable_get(name).inspect}, " }.join
+      "\#<#{self.class.name} #{variables}@flag=#{inspect_flags}>"
+    end
+
+    private
+
+    def parse(string)
+      @buffer = string
+      signature, type = string.unpack('a8V')
+      raise ParseError, 'Unknown signature' if signature != SSP_SIGNATURE
+      raise ParseError, "Wrong type (expected #{self.class::TYPE}, but got #{type})" if type != self.class::TYPE
+    end
+
+    def append_payload(string, allocation_size = nil)
+      size = string.size
+      allocation_size ||= (size + 1) & ~1
+      string = string.ljust(allocation_size, "\0")
+      @buffer << string[0, allocation_size]
+      result = [size, allocation_size, @offset].pack('vvV')
+      @offset += allocation_size
+      result
+    end
+
+    def fetch_payload(fields)
+      size, _, offset = fields.unpack('vvV')
+      return nil if size.zero?
+      @buffer[offset, size]
+    end
+
+    def encode_version(array)
+      array.pack('CCvx3C')   # major, minor, build, ntlm revision
+    end
+
+    def decode_version(string)
+      string.unpack('CCvx3C')   # major, minor, build, ntlm revision
+    end
+
+    def decode_av_pair(string)
+      result = []
+      string = string.dup
+      while true
+        id, length = string.slice!(0, 4).unpack('vv')
+        value = string.slice!(0, length)
+
+        case sym = AV_PAIR_NAMES[id]
+        when :AV_EOL
+          break
+        when :AV_NB_COMPUTER_NAME, :AV_NB_DOMAIN_NAME, :AV_DNS_COMPUTER_NAME, :AV_DNS_DOMAIN_NAME, :AV_DNS_TREE_NAME, :AV_TARGET_NAME
+          value = decode_utf16(value)
+        when :AV_FLAGS
+          value = data.unpack('V').first
+        end
+
+        result << [sym, value]
+      end
+      result
+    end
+
+    def encode_av_pair(av_pair)
+      result = ''
+      av_pair.each do |(id, value)|
+        case id
+        when :AV_NB_COMPUTER_NAME, :AV_NB_DOMAIN_NAME, :AV_DNS_COMPUTER_NAME, :AV_DNS_DOMAIN_NAME, :AV_DNS_TREE_NAME, :AV_TARGET_NAME
+          value = encode_utf16(value)
+        when :AV_FLAGS
+          value = [data].pack('V')
+        end
+        result << [AV_PAIRS[id], value.size, value].pack('vva*')
+      end
+
+      result << [AV_EOL, 0].pack('vv')
+    end
+
+
+    # [MS-NLMP] 2.2.1.1
+    class Negotiate < Message
+
+      TYPE          = 1
+      ATTRIBUTES    = [:domain, :workstation, :version]
+      DEFAULT_FLAGS = [NEGOTIATE_UNICODE, NEGOTIATE_OEM, REQUEST_TARGET, NEGOTIATE_NTLM, NEGOTIATE_ALWAYS_SIGN, NEGOTIATE_EXTENDED_SECURITY].inject(:|)
+
+      attr_accessor(*ATTRIBUTES)
+
+      def parse(string)
+        super
+        @flag, domain, workstation, version = string.unpack('x12Va8a8a8')
+        @domain      = fetch_payload(domain) if has_flag?(:OEM_DOMAIN_SUPPLIED)
+        @workstation = fetch_payload(workstation) if has_flag?(:OEM_WORKSTATION_SUPPLIED)
+        @version     = decode_version(version)  if has_flag?(:NEGOTIATE_VERSION)
+        self
+      end
+
+      def serialize
+        @buffer = ''
+        @offset = 40  # (8 + 4) + 4 + (8 * 3)
+
+        if @domain
+          set(:OEM_DOMAIN_SUPPLIED)
+          domain = append_payload(@domain)
+        end
+
+        if @workstation
+          set(:OEM_WORKSTATION_SUPPLIED)
+          workstation = append_payload(@workstation)
+        end
+
+        if @version
+          set(:NEGOTIATE_VERSION)
+          version = encode_version(@version)
+        end
+
+        [SSP_SIGNATURE, TYPE, @flag, domain, workstation, version].pack('a8VVa8a8a8') + @buffer
+      end
+
+    end # Negotiate
+
+
+    # [MS-NLMP] 2.2.1.2
+    class Challenge < Message
+
+      TYPE          = 2
+      ATTRIBUTES    = [:target_name, :challenge, :target_info, :version]
+      DEFAULT_FLAGS = 0
+
+      attr_accessor(*ATTRIBUTES)
+
+      def parse(string)
+        super
+        target_name, @flag, @challenge, target_info, version = string.unpack('x12a8Va8x8a8a8')
+        @target_name = fetch_payload(target_name) if has_flag?(:REQUEST_TARGET)
+        @target_info = fetch_payload(target_info) if has_flag?(:NEGOTIATE_TARGET_INFO)
+        @version     = decode_version(version)  if has_flag?(:NEGOTIATE_VERSION)
+
+        @target_name &&= decode_utf16(@target_name) if unicode?
+        @target_info &&= decode_av_pair(@target_info)
+
+        self
+      end
+
+      def serialize
+        @buffer = ''
+        @offset = 56  # (8 + 4) + 8 + 4 + (8 * 4)
+
+        @challenge ||= OpenSSL::Random.random_bytes(8)
+
+        if @target_name
+          set(:REQUEST_TARGET)
+          if unicode?
+            target_name = append_payload(encode_utf16(@target_name))
+          else
+            target_name = append_payload(@target_name)
+          end
+        end
+
+        if @target_info
+          set(:NEGOTIATE_TARGET_INFO)
+          target_info = append_payload(encode_av_pair(@target_info))
+        end
+
+        if @version
+          set(:NEGOTIATE_VERSION)
+          version = encode_version(@version)
+        end
+
+        [SSP_SIGNATURE, TYPE, target_name, @flag, @challenge, target_info, version].pack('a8Va8Va8x8a8a8') + @buffer
+      end
+
+    end # Challenge
+
+
+    # [MS-NLMP] 2.2.1.3
+    class Authenticate < Message
+
+      TYPE          = 3
+      ATTRIBUTES    = [:lm_response, :nt_response, :domain, :user, :workstation, :session_key, :version, :mic]
+      DEFAULT_FLAGS = [NEGOTIATE_UNICODE, REQUEST_TARGET, NEGOTIATE_NTLM, NEGOTIATE_ALWAYS_SIGN, NEGOTIATE_EXTENDED_SECURITY].inject(:|)
+
+      attr_accessor(*ATTRIBUTES)
+
+      def parse(string)
+        super
+        lm_response, nt_response, domain, user, workstation, session_key, @flag, version, mic = \
+          string.unpack('x12a8a8a8a8a8a8Va8a16')
+
+        @lm_response = fetch_payload(lm_response)
+        @nt_response = fetch_payload(nt_response)
+        @domain      = fetch_payload(domain)
+        @user        = fetch_payload(user)
+        @workstation = fetch_payload(workstation)
+        @session_key = fetch_payload(session_key) if has_flag?(:NEGOTIATE_KEY_EXCH)
+        @version     = decode_version(version) if has_flag?(:NEGOTIATE_VERSION)
+        @mic         = mic
+
+        if unicode?
+          @domain      = decode_utf16(@domain)
+          @user        = decode_utf16(@user)
+          @workstation = decode_utf16(@workstation)
+        end
+
+        self
+      end
+
+      def serialize
+        @buffer = ''
+        @offset = 88  # (8 + 4) + (8 * 6) + 4 + 8 + 16
+
+        lm_response = append_payload(@lm_response)
+        nt_response = append_payload(@nt_response)
+
+        if unicode?
+          domain      = append_payload(encode_utf16(@domain))
+          user        = append_payload(encode_utf16(@user))
+          workstation = append_payload(encode_utf16(@workstation))
+        else
+          domain      = append_payload(@domain)
+          user        = append_payload(@user)
+          workstation = append_payload(@workstation)
+        end
+
+        if @session_key
+          set(:NEGOTIATE_KEY_EXCH)
+          session_key = append_payload(@session_key)
+        end
+
+        if @version
+          set(:NEGOTIATE_VERSION)
+          version = encode_version(@version)
+        end
+
+        [SSP_SIGNATURE, TYPE, lm_response, nt_response, domain, user, workstation, session_key, @flag, version, @mic].pack('a8Va8a8a8a8a8a8Va8a16') + @buffer
+      end
+
+    end # Authenticate
+
+  end # Message
+end # NTLM

data/lib/net/smtp/ntlm/util.rb

@@ -0,0 +1,108 @@
+require 'openssl'
+
+module Net::SMTP::NTLM
+  module Util
+
+    LM_MAGIC_TEXT = 'KGS!@#$%'
+
+    module_function
+
+    if RUBY_VERSION >= '1.9'
+
+      def decode_utf16(str)
+        str.encode(Encoding::UTF_8, Encoding::UTF_16LE)
+      end
+
+      def encode_utf16(str)
+        str.to_s.encode(Encoding::UTF_16LE).force_encoding(Encoding::ASCII_8BIT)
+      end
+
+    else
+
+      require 'iconv'
+
+      def decode_utf16(str)
+        Iconv.conv('UTF-8', 'UTF-16LE', str)
+      end
+
+      def encode_utf16(str)
+        Iconv.conv('UTF-16LE', 'UTF-8', str)
+      end
+
+    end
+
+    def create_des_keys(string)
+      keys = []
+      string = string.dup
+      until (key = string.slice!(0, 7)).empty?
+        # key is 56 bits
+        key = key.unpack('B*').first
+        str = ''
+        until (bits = key.slice!(0, 7)).empty?
+          str << bits
+          str << (bits.count('1').even? ? '1' : '0')  # parity
+        end
+        keys << [str].pack('B*')
+      end
+      keys
+    end
+
+    def encrypt(plain_text, key, key_length)
+      key = key.ljust(key_length, "\0")
+      keys = create_des_keys(key[0, key_length])
+
+      result = ''
+      cipher = OpenSSL::Cipher::DES.new
+      keys.each do |k|
+        cipher.encrypt
+        cipher.key = k
+
+        encrypted_text = cipher.update(plain_text)
+        encrypted_text << cipher.final
+        result << encrypted_text[0...8]
+      end
+
+      result
+    end
+
+    # [MS-NLMP] 3.3.1
+    def lm_v1_hash(password)
+      encrypt(LM_MAGIC_TEXT, password.upcase, 14)
+    end
+
+    # [MS-NLMP] 3.3.1
+    def nt_v1_hash(password)
+      OpenSSL::Digest::MD4.digest(encode_utf16(password))
+    end
+
+    # [MS-NLMP] 3.3.1
+    def ntlm_v1_response(challenge, password, options = {})
+      if options[:ntlm_v2_session]
+        challenge = challenge.b if challenge.respond_to?(:b)
+        client_challenge = options[:client_challenge] || OpenSSL::Random.random_bytes(8)
+        client_challenge = client_challenge.b if client_challenge.respond_to?(:b)
+        hash = OpenSSL::Digest::MD5.digest(challenge + client_challenge)[0, 8]
+        nt_response = encrypt(hash, nt_v1_hash(password), 21)
+        lm_response = client_challenge + ("\0" * 16)
+      else
+        nt_response = encrypt(challenge, nt_v1_hash(password), 21)
+        lm_response = encrypt(challenge, lm_v1_hash(password), 21)
+      end
+
+      [nt_response, lm_response]
+    end
+
+
+    # [MS-NLMP] 3.3.2
+    def nt_v2_hash(user, password, domain)
+      user_domain = encode_utf16(user.upcase + domain)
+      OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, nt_v1_hash(password), user_domain)
+    end
+
+    # [MS-NLMP] 3.3.2
+    def ntlm_v2_response(*)
+      raise NotImplemnetedError
+    end
+
+  end # Util
+end # NTLM

data/lib/net/smtp/ntlm/version.rb

@@ -0,0 +1,5 @@
+require 'net/smtp'
+
+module Net::SMTP::NTLM
+  VERSION = '0.0.1'
+end

data/lib/net/smtp/ntlm.rb

@@ -0,0 +1,27 @@
+require 'net/smtp'
+require 'net/smtp/ntlm/util'
+require 'net/smtp/ntlm/message'
+require 'net/smtp/ntlm/auth_ntlm'
+
+module Net::SMTP::NTLM
+  def self.negotiate(args = {})
+    Message::Negotiate.new(args)
+  end
+
+  def self.authenticate(challenge_message, user, domain, password, options = {})
+    challenge = Net::SMTP::NTLM::Message::Challenge.parse(challenge_message)
+
+    opt = options.merge({
+      :ntlm_v2_session => challenge.has_flag?(:NEGOTIATE_EXTENDED_SECURITY),
+    })
+    nt_response, lm_response = Net::SMTP::NTLM::Util.ntlm_v1_response(challenge.challenge, password, opt)
+
+    Net::SMTP::NTLM::Message::Authenticate.new(
+      :user        => user,
+      :domain      => domain,
+      :lm_response => lm_response,
+      :nt_response => nt_response
+    )
+  end
+
+end # NTLM

data/net-smtp-ntlm.gemspec

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'net/smtp/ntlm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'net-smtp-ntlm'
+  spec.version       = Net::SMTP::NTLM::VERSION
+  spec.summary       = 'Add-on for net-smtp gem to add NTLM support.'
+  spec.description   = 'Add-on for net-smtp gem to add NTLM support.'
+
+  spec.authors       = ['Fedosov Sergey (RnD Soft)']
+  spec.email         = 'info@rnds.pro'
+  spec.homepage      = 'https://rnds.pro'
+
+  spec.add_runtime_dependency 'net-smtp', '~> 0.4.0'
+
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "test-unit"
+
+  spec.files         = %w[README.md CHANGELOG.md net-smtp-ntlm.gemspec] + Dir['lib/**/*.rb']
+  spec.require_paths = ['lib']
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: net-smtp-ntlm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Fedosov Sergey (RnD Soft)
+autorequire:
+bindir: bin
+cert_chain: []
+date:
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-smtp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Add-on for net-smtp gem to add NTLM support.
+email: info@rnds.pro
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- CHANGELOG.md
+- net-smtp-ntlm.gemspec
+- lib/net/smtp/ntlm/auth_ntlm.rb
+- lib/net/smtp/ntlm/message.rb
+- lib/net/smtp/ntlm/util.rb
+- lib/net/smtp/ntlm/version.rb
+- lib/net/smtp/ntlm.rb
+homepage: https://rnds.pro
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Add-on for net-smtp gem to add NTLM support.
+test_files: []