active_attack 0.1.14

data/app/assets/stylesheets/active_attack/tactics.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/app/assets/stylesheets/active_attack/versions.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/app/controllers/active_attack/application_controller.rb

@@ -0,0 +1,5 @@
+module ActiveAttack
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+  end
+end

data/app/controllers/active_attack/matrices_controller.rb

@@ -0,0 +1,82 @@
+class ActiveAttack::MatricesController < ApplicationController
+  before_action :set_matrix, only: [:show, :edit, :update, :destroy, :data]
+
+  # GET /attack/matrices
+  # GET /attack/matrices.json
+  def index
+    @attack_matrices = ActiveAttack::Matrix.all
+  end
+
+  # GET /attack/matrices/1
+  # GET /attack/matrices/1.json
+  def show
+    @attack_matrix = ActiveAttack::Matrix.find(params[:id])
+  end
+
+
+  # GET /attack/matrices/new
+  def new
+    @attack_matrix = ActiveAttack::Matrix.new
+  end
+
+  # GET /attack/matrices/1/edit
+  def edit
+  end
+
+  def data
+  end
+
+  # POST /attack/matrices
+  # POST /attack/matrices.json
+  def create
+    @attack_matrix = ActiveAttack::Matrix.new(attack_matrix_params)
+
+    respond_to do |format|
+      if @attack_matrix.save
+        bundle = @attack_matrix.ingest_bundle(params[:attack_matrix][:uploaded_file].path)
+        @attack_matrix.update(:stix_bundle_id => bundle.stix_id)
+        format.html { redirect_to @attack_matrix, notice: 'Attack matrix was successfully created.' }
+        format.json { render :show, status: :created, location: @attack_matrix }
+      else
+        format.html { render :new }
+        format.json { render json: @attack_matrix.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /stix/matrices/1
+  # PATCH/PUT /stix/matrices/1.json
+  def update
+    respond_to do |format|
+      if @attack_matrix.update(attack_attack_matrix_params)
+        format.html { redirect_to @attack_matrix, notice: 'Attack matrix was successfully updated.' }
+        format.json { render :show, status: :ok, location: @attack_matrix }
+      else
+        format.html { render :edit }
+        format.json { render json: @attack_matrix.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /attack/matrices/1
+  # DELETE /attack/matrices/1.json
+  def destroy
+    @attack_matrix.destroy
+    respond_to do |format|
+      format.html { redirect_to attack_attack_matrices_url, notice: 'Attack matrix was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_matrix
+      #@attack_pattern = ActiveStix::AttackPattern.find(params[:id])
+      @matrix = ActiveAttack::Matrix.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def attack_matrix_params
+      params.require(:attack_matrix).permit(:stix_bundle_id, :name)
+    end
+end

data/app/controllers/active_attack/playbooks_controller.rb

@@ -0,0 +1,89 @@
+class ActiveAttack::PlaybooksController < ApplicationController
+  before_action :set_attack_playbook, only: [:edit, :update, :destroy]
+
+  # GET /attack/playbooks
+  # GET /attack/playbooks.json
+  def index
+    @playbooks = ActiveAttack::Playbook.all
+  end
+
+  # GET /attack/playbooks/1
+  # GET /attack/playbooks/1.json
+  def show
+    # @attack_playbook.stix_bundle.bundled_objects.each do | x |
+    #   render :json => @attack_playbook.stix_bundle
+    # end
+    @playbooks = ActiveAttack::Playbook.all
+    @playbook = @playbooks.find(params[:id])
+    @threat_actor = @playbook.threat_actor
+    @report = @playbook.bundle
+
+    respond_to do |format|
+      format.html
+      format.json {render json: @playbook.as_stix}
+    end
+  end
+
+  # GET /attack/playbooks/new
+  def new
+    @attack_playbook = ActiveAttack::Playbook.new
+  end
+
+  # GET /attack/playbooks/1/edit
+  def edit
+  end
+
+  # POST /attack/playbooks
+  # POST /attack/playbooks.json
+  def create
+    @attack_playbook = ActiveAttack::Playbook.new(attack_playbook_params)
+
+    respond_to do |format|
+      if @attack_playbook.save
+        bundle = @attack_playbook.ingest_bundle(params[:attack_playbook][:uploaded_file].path)
+        @attack_playbook.update(:stix_bundle_id => bundle.stix_id)
+        format.html { redirect_to @attack_playbook, notice: 'Playbook was successfully created.' }
+        format.json { render :show, status: :created, location: @attack_playbook }
+      else
+        format.html { render :new }
+        format.json { render json: @attack_playbook.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /attack/playbooks/1
+  # PATCH/PUT /attack/playbooks/1.json
+  def update
+    respond_to do |format|
+      if @attack_playbook.update(attack_playbook_params)
+        format.html { redirect_to @attack_playbook, notice: 'Playbook was successfully updated.' }
+        format.json { render :show, status: :ok, location: @attack_playbook }
+      else
+        format.html { render :edit }
+        format.json { render json: @attack_playbook.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /attack/playbooks/1
+  # DELETE /attack/playbooks/1.json
+  def destroy
+    @attack_playbook.destroy
+    respond_to do |format|
+      format.html { redirect_to attack_playbooks_url, notice: 'Playbook was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+
+  # Use callbacks to share common setup or constraints between actions.
+  def set_attack_playbook
+    @attack_playbook = ActiveAttack::Playbook.find(params[:id])
+  end
+
+  # Never trust parameters from the scary internet, only allow the white list through.
+  def attack_playbook_params
+    params.require(:attack_playbook).permit(:name, :stix_bundle_id, :id)
+  end
+end

data/app/controllers/active_attack/tactics_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_attack/application_controller"
+
+module ActiveAttack
+  class TacticsController < ApplicationController
+    before_action :set_tactic, only: [:show, :edit, :update, :destroy]
+
+    # GET /tactics
+    def index
+      @tactics = Tactic.all
+    end
+
+    # GET /tactics/1
+    def show
+    end
+
+    # GET /tactics/new
+    def new
+      @tactic = Tactic.new
+    end
+
+    # GET /tactics/1/edit
+    def edit
+    end
+
+    # POST /tactics
+    def create
+      @tactic = Tactic.new(tactic_params)
+
+      if @tactic.save
+        redirect_to @tactic, notice: 'Tactic was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /tactics/1
+    def update
+      if @tactic.update(tactic_params)
+        redirect_to @tactic, notice: 'Tactic was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /tactics/1
+    def destroy
+      @tactic.destroy
+      redirect_to tactics_url, notice: 'Tactic was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_tactic
+        @tactic = Tactic.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def tactic_params
+        params.require(:tactic).permit(:stix_id, :name, :description, :shortname, :created_by_ref)
+      end
+  end
+end

data/app/helpers/active_attack/application_helper.rb

@@ -0,0 +1,4 @@
+module ActiveAttack
+  module ApplicationHelper
+  end
+end

data/app/helpers/active_attack/playbooks_helper.rb

@@ -0,0 +1,21 @@
+module ActiveAttack
+  module PlaybooksHelper
+    def attack_pattern_class(phase, row)
+      if @playbook.attack_patterns.collect(&:name).include? @playbook.attack_pattern_matrix(phase.name, row)
+        "used"
+      end
+    end
+
+    def campaign_list(phase, row)
+      @playbook.attack_pattern_campaign_list(phase,row)
+    end
+
+    def attack_pattern_target(phase, row)
+      if @playbook.attack_patterns.collect(&:name).include? @playbook.attack_pattern_matrix(phase.name, row)
+        "matrix.used"
+      else
+        "matrix.notused"
+      end
+    end
+  end
+end

data/app/helpers/active_attack/tactics_helper.rb

@@ -0,0 +1,4 @@
+module ActiveAttack
+  module TacticsHelper
+  end
+end

data/app/jobs/active_attack/application_job.rb

@@ -0,0 +1,4 @@
+module ActiveAttack
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/active_attack/application_mailer.rb

@@ -0,0 +1,6 @@
+module ActiveAttack
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/active_attack/active_attack.rb

@@ -0,0 +1,7 @@
+module ActiveAttack
+  module ActiveAttack
+    def self.table_name_prefix
+      'active_attack_active_attack_'
+    end
+  end
+end

data/app/models/active_attack/application_record.rb

@@ -0,0 +1,5 @@
+module ActiveAttack
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/active_attack/build.rb

@@ -0,0 +1,6 @@
+module ActiveAttack
+  class Build < ApplicationRecord
+    belongs_to :buildable, polymorphic: true
+    belongs_to :platform
+  end
+end

data/app/models/active_attack/data_source.rb

@@ -0,0 +1,15 @@
+module ActiveAttack
+  class DataSource < ApplicationRecord
+    has_many :attack_patterns, :class_name => 'ActiveStix::AttackPattern', through: :data_source_attack_pattern
+
+    def self.create_source(src)
+      xmd = find_or_create_by(source:src)
+      xmd
+    end
+
+    def convert_to_json
+      source
+    end
+
+  end
+end

data/app/models/active_attack/detection.rb

@@ -0,0 +1,14 @@
+module ActiveAttack
+  class Detection < ApplicationRecord
+    has_many :attack_patterns, :class_name => 'ActiveStix::AttackPattern', through: :detection_attack_pattern
+
+    def self.create_descr(descr)
+      xmd = find_or_create_by(description:descr)
+      xmd
+    end
+
+    def convert_to_json
+      description
+    end
+  end
+end

data/app/models/active_attack/difficulty_for_adversary.rb

@@ -0,0 +1,10 @@
+module ActiveAttack
+  class DifficultyForAdversary < ApplicationRecord
+    has_many :attack_patterns, :class_name => 'ActiveStix::AttackPattern', through: :difficulty_for_adversary_attack_pattern
+
+    def self.create_difficulty(diff)
+      isDiff = find_or_create_by(difficulty:diff)
+      isDiff
+    end
+  end
+end

data/app/models/active_attack/matrix.rb

@@ -0,0 +1,82 @@
+module ActiveAttack
+  class Matrix < ApplicationRecord
+    belongs_to :bundle, :class_name => 'ActiveStix::Bundle', optional: true
+
+    has_many :reference_items, class_name: "ActiveStix::ReferenceItem", as: :referrer
+    has_many :external_references, class_name: "ActiveStix::ExternalReference", through: :reference_items
+    has_many :tactics, primary_key: 'stix_id', foreign_key: 'matrix_ref'
+
+    def ingest_bundle(path)
+      bundle = ActiveStix::Bundle.ingest(path)
+      self.bundle = bundle
+      save
+      bundle
+    end
+
+
+    def self.ingest_json(obj)
+      binding.pry
+      xmx = find_or_create_by(stix_id:obj['id'], name:obj['name'])
+
+      if obj.has_key?('description')
+        xmx.description = obj['description']
+      end
+
+      if obj.has_key?('created_by_ref')
+        xmx.created_by_ref = obj['created_by_ref']
+      end
+
+      if obj.has_key?('external_references')
+        obj['external_references'].each do |er|
+          external_reference = ActiveStix::ExternalReference.ingest_json(er, obj['id'])
+          xmx.external_references << external_reference unless ActiveStix::ReferenceItem.find_by(external_reference_id:external_reference.id, referrer_id:xmx.id, referrer_type: "ActiveAttack::Matrix")
+        end
+      end
+
+      if obj.has_key?('object_marking_refs')
+        # todo
+      end
+
+      if obj.has_key?('tactic_refs')
+        obj['tactic_refs'].each do |tr|
+          tactic_ref = ActiveAttack::Tactic.find_or_create_by(stix_id: tr)
+          xmx.tactics << tactic_ref
+        end
+      end
+
+      xmx.save
+      xmx
+    end
+
+    def convert_to_json
+      external_refs_arr = []
+      external_references.each do | x |
+        external_refs_arr << x.convert_to_json
+      end
+
+      marking_def_arr = []
+      marking_definitions.each do | x |
+        marking_def_arr << x.convert_to_json
+      end
+
+
+      tactic_refs_arr = []
+      x_mitre_tactic_refs.each do | x |
+        tactic_refs_arr << x.convert_to_json
+      end
+
+      {
+          :external_references => external_refs_arr,
+          :object_marking_refs => marking_def_arr,
+          :id => stix_id,
+          :name => name,
+          :created => created_at.to_s,
+          :modified => updated_at.to_s,
+          :type => "x-mitre-matrix",
+          :created_by_ref => created_by_ref,
+          :description => description,
+          :tactic_refs => tactic_refs_arr
+      }
+    end
+  end
+end