codtls 0.0.1.alpha

data/lib/codtls/session.rb

@@ -0,0 +1,284 @@
+require 'active_record'
+require 'sqlite3'
+require 'pathname'
+
+require 'codtls/abstract_session'
+require 'codtls/models/codtls_connection'
+
+module CoDTLS
+  # Error class for wrong data inputs (for exampe keyblock)
+  class SessionError < StandardError
+  end
+
+  # Storage class for a CoDTLS-Session with the following Fields:
+  #
+  # TABLE 1
+  # Type     | Name               | Standard-Value
+  # -------------------------------------------------------
+  # uint8_t  | uuid[16];          | uuid - couldnt be empty
+  # uint8_t  | psk[16];           | psk  - couldnt be empty
+  # uint8_t  | psk_new[16];       | empty
+  #
+  # TABLE 2
+  # Type     | Name               | Standard-Value
+  # -------------------------------------------------------
+  # uint8_t  | ip[16];            | Given IP
+  # uint8_t  | id[8];             | empty
+  # uint16_t | epoch;             | 0
+  # uint48_t | seq_num_r;         | depends on implementation (-1, 0 or 1)
+  # uint48_t | seq_num_w;         | depends on implementation (-1, 0 or 1)
+  # uint8_t  | key_block[40];     | empty
+  # uint8_t  | key_block_new[40]; | empty
+  # uint8_t  | handshake;         | 0
+  class Session < CoDTLS::AbstractSession
+    @ip_list = []
+    def self.ip_list
+      @ip_list
+    end
+
+    # Constructor to create a new session for the given ip. When only ip is
+    # given, its the value for searching in database. When its not found, a
+    # new database entry with standard values will be created. When id is
+    # also given, id is the first value for searching in database. When its
+    # found, ip will be updated and other values are unchanged. In the other
+    # case, when id isnt found, its the same behavior as without id but with
+    # additional storing of the id. Throws excpetion if ip == nil.
+    #
+    # @param ip [IP] IP for this Session
+    # @param id [String] Session-Id for this Session
+    def initialize(ip, id = nil)
+      # logger = Logger.new(STDOUT)
+      # logger.level = CoDTLS::LOG_LEVEL
+      # logger.debug("Session wird erstellt")
+      fail SessionError 'IP is nil, not a valid value.' if ip.nil? ||
+                                                           ip.class != String
+      # normalize IP
+      ip = IPAddr.new(ip)
+      fail SessionError 'IP is not in a valid format' if ip.nil?
+      @ip = ip.to_s
+
+      # Find IP Object, if not found -> create it
+      database_entry = CoDTLS::Session.ip_list.select { |i| i[0] == @ip }
+      if database_entry.empty?
+        if id.nil?
+          create_standard_ip_entry
+        else
+          ActiveRecord::Base.connection_pool.with_connection do
+            database_entry = CODTLSConnection.find_by_id(id)
+          end
+          if (database_entry.nil?)
+            create_standard_ip_entry
+          else
+            CoDTLS::Session.ip_list.push([ip, database_entry])
+          end
+          database_entry.session_id = id.to_s
+          database_entry.save
+        end
+      else
+        database_entry = database_entry[0][1]
+      end
+      ObjectSpace.define_finalizer(self, proc { entry = get_database_entry(ip)
+                                                entry.save unless entry.nil? })
+    end
+
+    # Sets the ID of the current session.
+    #
+    # @param id [String] the Session-Id
+    def id=(id)
+      database_entry = get_database_entry(@ip)
+      database_entry.session_id = id
+      database_entry.save
+    end
+
+    # Returns the ID of the current session.
+    #
+    # @return [String] the Session-ID. nil if Session-ID is unknown
+    def id
+      database_entry = get_database_entry(@ip)
+      return nil if database_entry.session_id.nil?
+      database_entry.session_id
+    end
+
+    # Returns the Epoch of the session for the specified IP.
+    #
+    # @return [Number] the Epoch
+    def epoch
+      database_entry = get_database_entry(@ip)
+      database_entry.epoch
+    end
+
+    # Increases the Epoch of the session by 1.
+    # Also copy key_block_new to key_block and sets key_block_new to empty.
+    # seq_num_r and seq_num_w are set back to standard value.
+    # Throws excpetion if keyblock is not 40 bytes long.
+    def increase_epoch
+      database_entry = get_database_entry(@ip)
+
+      if database_entry.key_block_new.nil?
+        fail CoDTLS::SessionError, 'no new keyblock to set for this epoch.'
+      end
+      database_entry.epoch = database_entry.epoch + 1
+      database_entry.seq_num_r = 0
+      database_entry.seq_num_w = 0
+      database_entry.key_block = database_entry.key_block_new
+      database_entry.key_block_new = nil
+
+      ActiveRecord::Base.connection_pool.with_connection do
+        database_entry.save
+      end
+    end
+
+    # Checks the sequenze number of an incoming paket. Valid number is
+    # -10 ... + 100 of the expected number.
+    # The inital LAST number is 0, so the next expected is 1.
+    #
+    # @param num [Number] the recieved sequence number
+    # @return [Bool] true if the number is valid. false if invalid
+    def check_seq(num)
+      database_entry = get_database_entry(@ip)
+      return false if num < database_entry.seq_num_r - 9 ||
+                      num > database_entry.seq_num_r + 101
+      true
+    end
+
+    # Sets the sequence number of the last received paket.
+    #
+    # @param num [Number] the new sequence number
+    def seq=(num)
+      database_entry = get_database_entry(@ip)
+      database_entry.seq_num_r = num
+      database_entry.save
+      true
+    end
+
+    # Returns the sequence number for the next outgoing paket.
+    # The inital sequence number is 1. Every return value needs
+    # to be last value + 1.
+    #
+    # @return [Number] the sequence number for the next outgoing paket
+    def seq
+      database_entry = get_database_entry(@ip)
+      database_entry.seq_num_w += 1
+      database_entry.save
+      database_entry.seq_num_w
+    end
+
+    # Inserts a new keyblock to key_block_new. Throws excpetion if
+    # keyblock is not 40 bytes long.
+    #
+    # @param keyBlock [String] the 40 byte long new keyblock to be inserted
+    def key_block=(keyBlock)
+      if keyBlock.b.length != 40
+        fail CoDTLS::SessionError, 'key blocks have to be 40 byte long'
+      end
+      database_entry = get_database_entry(@ip)
+      database_entry.key_block_new = keyBlock
+      database_entry.save
+    end
+
+    # Returns the active keyblock (key_block) for the specified IP.
+    # If keyblock is empty, nil will be returned.
+    #
+    # @return [String] the 40 byte long keyblock or nil if empty
+    def key_block
+      database_entry = get_database_entry(@ip)
+      database_entry.key_block
+    end
+
+    # Causes the next messages to be send as handshake messages.
+    def enable_handshake
+      database_entry = get_database_entry(@ip)
+      database_entry.handshake = true
+      database_entry.save
+      true
+    end
+
+    # Causes the next messages to not be send as handshake messages.
+    def disable_handshake
+      database_entry = get_database_entry(@ip)
+      database_entry.handshake = false
+      database_entry.save
+      true
+    end
+
+    # Checks if the next message should be send as a handshake message.
+    #
+    # @return [Bool] true if the next messages are handshake messages
+    def handshake?
+      database_entry = get_database_entry(@ip)
+      database_entry.handshake
+    end
+
+    # Removes the whole entry from database.
+    def clear
+      database_entry = nil
+      ActiveRecord::Base.connection_pool.with_connection do
+        database_entry = CODTLSConnection.find_by_ip(@ip)
+      end
+      if database_entry
+        ActiveRecord::Base.connection_pool.with_connection do
+          database_entry.destroy
+        end
+        entry = CoDTLS::Session.ip_list.select { |i| i[1] == database_entry }
+        return nil if entry.empty?
+        CoDTLS::Session.ip_list.delete(entry[0])
+        # database_entry.session_id = nil
+        # database_entry.epoch = 0
+        # database_entry.seq_num_r = 0
+        # database_entry.seq_num_w = 0
+        # database_entry.key_block = nil
+        # database_entry.key_block_new = nil
+        # database_entry.handshake = false
+        # database_entry.save
+        # database_entry = nil
+      end
+    end
+
+    def get_database_entry(ip)
+      # mutex lock
+      entry = CoDTLS::Session.ip_list.select { |i| i[1].ip == ip }
+      if entry.empty?
+        entry = create_standard_ip_entry
+        # return the new entry
+      else
+        entry = entry[0][1]
+      end
+      return entry
+      # mutex unlock
+    end
+
+    def self.clear_all
+      # ActiveRecord::Base.connection_pool.with_connection do
+      #   CoDTLSConnection.destroy_all
+      # end
+      @ip_list = []
+    end
+
+    private
+
+    def create_standard_ip_entry
+      database_entry = nil
+      ActiveRecord::Base.connection_pool.with_connection do
+        if (database_entry = CODTLSConnection.find_by_ip(@ip)).nil?
+          database_entry = CODTLSConnection.create(ip: @ip,
+                                                    epoch: 0,
+                                                    handshake: false,
+                                                    seq_num_w: 0,
+                                                    seq_num_r: 0
+                                                    )
+          database_entry.save
+          CoDTLS::Session.ip_list.push([@ip, database_entry])
+        end
+      end
+      return database_entry
+    end
+  end
+end
+
+def create_sqlite_db(dbname)
+  SQLite3::Database.new(dbname)
+end
+
+# refactoren: jedes mal, wenn auf den "database_entry" zugegriffen wird,
+# muss er aus der Tabelle geholt werden. Am besten noch den Zugriff auf
+# die Tabelle mit nem Mutex schützen

data/lib/codtls/version.rb

@@ -0,0 +1,3 @@
+module CoDTLS
+  VERSION = '0.0.1.alpha'
+end

data/lib/generators/codtls/codtls_generator.rb

@@ -0,0 +1,56 @@
+# http://5minutenpause.com/blog/2012/06/03/install-generators-for-ruby-gems/
+# http://stackoverflow.com/questions/15671099/add-new-migrations-from-rails-
+#                                            engine-gem-to-app-via-generator
+
+# require 'rails/generators/migration'
+# module CoDTLS
+#   module Generators
+#     class InstallGenerator < Rails::Generators::Baseinclude
+#       include Rails::Generators::Migration
+#       source_root File.expand_path("../templates", __FILE__)
+#       def copy_migrations
+#         copy_migration "20140116124500_create_dtls_devices.rb"
+#         copy_migration "20140116124501_create_dtls_connections.rb"
+#       end
+
+#       protected
+
+#       def copy_migration(filename)
+#         if self.class.migration_exists?("db/migrate", "#{filename}")
+#           say_status("skipped", "Migration #{filename}.rb already exists")
+#         else
+#           migration_template "migrations/#{filename}.rb",
+#                              "db/migrate/#{filename}.rb"
+#         end
+#       end
+#     end
+#   end
+# end
+
+require 'rails/generators'
+require 'rails/generators/migration'
+
+# Description
+class CodtlsGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+
+  def self.source_root
+    @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+  end
+
+  def self.next_migration_number(dirname)
+    if ActiveRecord::Base.timestamped_migrations
+      sleep 0.2
+      Time.new.utc.strftime('%Y%m%d%H%M%S%L')
+    else
+      sprintf '%.3d', (current_migration_number(dirname) + 1)
+    end
+  end
+
+  def create_migration_file
+    migration_template 'create_codtls_devices.rb',
+                       'db/migrate/create_codtls_devices.rb'
+    migration_template 'create_codtls_connections.rb',
+                       'db/migrate/create_codtls_connections.rb'
+  end
+end

data/lib/generators/codtls/templates/create_codtls_connections.rb

@@ -0,0 +1,15 @@
+# Creates the base table for CoDTLS Connections
+class CreateCodtlsConnections < ActiveRecord::Migration
+  def change
+    create_table :codtls_connections do |t|
+      t.string :ip
+      t.string :session_id
+      t.integer :epoch
+      t.integer :seq_num_r
+      t.integer :seq_num_w
+      t.binary :key_block
+      t.binary :key_block_new
+      t.boolean :handshake
+    end
+  end
+end

data/lib/generators/codtls/templates/create_codtls_devices.rb

@@ -0,0 +1,11 @@
+# Creation of the Base Device Table
+class CreateCodtlsDevices < ActiveRecord::Migration
+  def change
+    create_table :codtls_devices do |t|
+      t.binary :uuid
+      t.string :psk
+      t.string :psk_new
+      t.string :desc
+    end
+  end
+end

data/test/test_codtls.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+require 'codtls'
+
+# Testclass
+class CoDTLSTest < Minitest::Test
+  def setup
+    fail CoDTLS::SessionError 'testdatabase already exists' if File.exist?(
+                                                         'testdatabase.sqlite')
+    SQLite3::Database.new('testdatabase.sqlite')
+    ActiveRecord::Base.establish_connection(
+      adapter: 'sqlite3',
+      database: 'testdatabase.sqlite')
+    ActiveRecord::Base.connection
+    ActiveRecord::Migration.verbose = false # debug messages
+    ActiveRecord::Migrator.migrate 'db/migrate'
+    @session = CoDTLS::Session.new('127.0.0.1')
+  end
+
+  def teardown
+    ActiveRecord::Base.remove_connection
+    FileUtils.rm('testdatabase.sqlite') if File.exist?('testdatabase.sqlite')
+  end
+
+  def info(numeric_address, code)
+    assert_equal numeric_address, '::1'
+    @listener_test = 1 if numeric_address == '::1'
+  end
+
+=begin
+  def test_listener
+    @listener_test = 0
+    CoDTLS::SecureSocket.add_new_node_listener(self)
+    sleep(1)
+    d = UDPSocket.new(Socket::AF_INET6)
+    d.connect('::1', 5684)
+    d.send("\x50\x03\x00", 0)
+    sleep(1)
+    assert_equal 1, @listener_test
+    d.close
+  end
+=end
+
+  def test_psk
+    assert_equal [], CoDTLS::SecureSocket.psks
+
+    CoDTLS::SecureSocket.add_psk(
+      ['a9d984d1fe2b4c06afe8da98d8924005'].pack('H*'),
+      'ABCDEFGHIJKLMNOP', 'Temperaturgerät 1')
+    assert_equal [[['a9d984d1fe2b4c06afe8da98d8924005'].pack('H*'),
+                   'ABCDEFGHIJKLMNOP', 'Temperaturgerät 1']],
+                 CoDTLS::SecureSocket.psks
+
+    CoDTLS::SecureSocket.del_psk(
+      ['a9d984d1fe2b4c06afe8da98d8924005'].pack('H*'))
+    assert_equal [], CoDTLS::SecureSocket.psks
+
+    CoDTLS::SecureSocket.add_psk(
+      ['a9d984d1fe2b4c06afe8da98d8924005'].pack('H*'),
+      'ABCDEFGHIJKLMNOP', 'Temperaturgerät 1')
+    CoDTLS::SecureSocket.add_psk(
+      ['9425f01d39034295ad9447161e13251b'].pack('H*'),
+      'abcdefghijklmnop', 'Rolladen Nummer 5')
+    assert_equal [[['a9d984d1fe2b4c06afe8da98d8924005'].pack('H*'),
+                   'ABCDEFGHIJKLMNOP', 'Temperaturgerät 1'],
+                  [['9425f01d39034295ad9447161e13251b'].pack('H*'),
+                   'abcdefghijklmnop', 'Rolladen Nummer 5']],
+                 CoDTLS::SecureSocket.psks
+
+    CoDTLS::SecureSocket.del_psk(
+      ['a9d984d1fe2b4c06afe8da98d8924005'].pack('H*'))
+    assert_equal [[['9425f01d39034295ad9447161e13251b'].pack('H*'),
+                   'abcdefghijklmnop', 'Rolladen Nummer 5']],
+                 CoDTLS::SecureSocket.psks
+  end
+end