active_stix 0.1.21

data/app/controllers/active_stix/application_controller.rb

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

data/app/controllers/active_stix/artifacts_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class ArtifactsController < ApplicationController
+    before_action :set_artifact, only: [:show, :edit, :update, :destroy]
+
+    # GET /artifacts
+    def index
+      @artifacts = Artifact.all
+    end
+
+    # GET /artifacts/1
+    def show
+    end
+
+    # GET /artifacts/new
+    def new
+      @artifact = Artifact.new
+    end
+
+    # GET /artifacts/1/edit
+    def edit
+    end
+
+    # POST /artifacts
+    def create
+      @artifact = Artifact.new(artifact_params)
+
+      if @artifact.save
+        redirect_to @artifact, notice: 'Artifact was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /artifacts/1
+    def update
+      if @artifact.update(artifact_params)
+        redirect_to @artifact, notice: 'Artifact was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /artifacts/1
+    def destroy
+      @artifact.destroy
+      redirect_to artifacts_url, notice: 'Artifact was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_artifact
+        @artifact = Artifact.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def artifact_params
+        params.require(:artifact).permit(:stix_id, :type, :mime_type, :payload_bin, :url, :hashes, :encryption_algorithm, :decryption_key)
+      end
+  end
+end

data/app/controllers/active_stix/attack_patterns_controller.rb

@@ -0,0 +1,27 @@
+class ActiveStix::AttackPatternsController < ApplicationController
+  before_action :set_attack_pattern, only: [:show, :edit, :update, :destroy, :data]
+  def index
+  end
+
+  def edit
+  end
+
+  def new
+  end
+
+  def show
+    #@attack_pattern = ActiveStix::AttackPattern.find(params[:id])
+  end
+
+  private
+  # Use callbacks to share common setup or constraints between actions.
+  def set_attack_pattern
+    @attack_pattern = ActiveStix::AttackPattern.find(params[:id])
+  end
+
+  # Never trust parameters from the scary internet, only allow the white list through.
+  def attack_pattern_params
+    params.require(:attack_matrix).permit(:id)
+  end
+
+end

data/app/controllers/active_stix/bcc_refs_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class BccRefsController < ApplicationController
+    before_action :set_bcc_ref, only: [:show, :edit, :update, :destroy]
+
+    # GET /bcc_refs
+    def index
+      @bcc_refs = BccRef.all
+    end
+
+    # GET /bcc_refs/1
+    def show
+    end
+
+    # GET /bcc_refs/new
+    def new
+      @bcc_ref = BccRef.new
+    end
+
+    # GET /bcc_refs/1/edit
+    def edit
+    end
+
+    # POST /bcc_refs
+    def create
+      @bcc_ref = BccRef.new(bcc_ref_params)
+
+      if @bcc_ref.save
+        redirect_to @bcc_ref, notice: 'Bcc ref was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /bcc_refs/1
+    def update
+      if @bcc_ref.update(bcc_ref_params)
+        redirect_to @bcc_ref, notice: 'Bcc ref was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /bcc_refs/1
+    def destroy
+      @bcc_ref.destroy
+      redirect_to bcc_refs_url, notice: 'Bcc ref was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_bcc_ref
+        @bcc_ref = BccRef.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def bcc_ref_params
+        params.require(:bcc_ref).permit(:email_message_id, :email_address_id)
+      end
+  end
+end

data/app/controllers/active_stix/bundled_objects_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class BundledObjectsController < ApplicationController
+    before_action :set_bundled_object, only: [:show, :edit, :update, :destroy]
+
+    # GET /bundled_objects
+    def index
+      @bundled_objects = BundledObject.all
+    end
+
+    # GET /bundled_objects/1
+    def show
+    end
+
+    # GET /bundled_objects/new
+    def new
+      @bundled_object = BundledObject.new
+    end
+
+    # GET /bundled_objects/1/edit
+    def edit
+    end
+
+    # POST /bundled_objects
+    def create
+      @bundled_object = BundledObject.new(bundled_object_params)
+
+      if @bundled_object.save
+        redirect_to @bundled_object, notice: 'Bundled object was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /bundled_objects/1
+    def update
+      if @bundled_object.update(bundled_object_params)
+        redirect_to @bundled_object, notice: 'Bundled object was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /bundled_objects/1
+    def destroy
+      @bundled_object.destroy
+      redirect_to bundled_objects_url, notice: 'Bundled object was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_bundled_object
+        @bundled_object = BundledObject.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def bundled_object_params
+        params.require(:bundled_object).permit(:bundle_ref, :object_ref, :object_type)
+      end
+  end
+end

data/app/controllers/active_stix/bundles_controller.rb

@@ -0,0 +1,11 @@
+class ActiveStix::BundlesController < ApplicationController
+  # GET /stix/bundle
+  # GET /stix/bundle.json
+  def index
+  end
+
+  def show
+    bundle = ActiveStix::Bundle.find(params[:id])
+    @bundle = JSON.parse(File.open("tmp/#{bundle.stix_id}.json", "r+").read)
+  end
+end

data/app/controllers/active_stix/campaigns_controller.rb

@@ -0,0 +1,74 @@
+class ActiveStix::CampaignsController < ApplicationController
+  before_action :set_stix_campaign, only: [:show, :edit, :update, :destroy]
+
+  # GET /stix/campaigns
+  # GET /stix/campaigns.json
+  def index
+    @campaigns = ActiveStix::Campaign.all
+  end
+
+  # GET /stix/campaigns/1
+  # GET /stix/campaigns/1.json
+  def show
+  end
+
+  # GET /stix/campaigns/new
+  def new
+    @campaign = ActiveStix::Campaign.new
+  end
+
+  # GET /stix/campaigns/1/edit
+  def edit
+  end
+
+  # POST /stix/campaigns
+  # POST /stix/campaigns.json
+  def create
+    @campaign = ActiveStix::Campaign.new(stix_campaign_params)
+
+    respond_to do |format|
+      if @campaign.save
+        format.html { redirect_to @campaign, notice: 'Campaign was successfully created.' }
+        format.json { render :show, status: :created, location: @campaign }
+      else
+        format.html { render :new }
+        format.json { render json: @campaign.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /stix/campaigns/1
+  # PATCH/PUT /stix/campaigns/1.json
+  def update
+    respond_to do |format|
+      if @campaign.update(stix_campaign_params)
+        format.html { redirect_to @campaign, notice: 'Campaign was successfully updated.' }
+        format.json { render :show, status: :ok, location: @campaign }
+      else
+        format.html { render :edit }
+        format.json { render json: @campaign.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /stix/campaigns/1
+  # DELETE /stix/campaigns/1.json
+  def destroy
+    @campaign.destroy
+    respond_to do |format|
+      format.html { redirect_to stix_campaigns_url, notice: 'Campaign was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_stix_campaign
+      @campaign = ActiveStix::Campaign.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def stix_campaign_params
+      params.require(:campaign).permit(:name, :description, :first_seen, :last_seen, :objective)
+    end
+end

data/app/controllers/active_stix/course_of_actions_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class CourseOfActionsController < ApplicationController
+    before_action :set_course_of_action, only: [:show, :edit, :update, :destroy]
+
+    # GET /course_of_actions
+    def index
+      @course_of_actions = CourseOfAction.all
+    end
+
+    # GET /course_of_actions/1
+    def show
+    end
+
+    # GET /course_of_actions/new
+    def new
+      @course_of_action = CourseOfAction.new
+    end
+
+    # GET /course_of_actions/1/edit
+    def edit
+    end
+
+    # POST /course_of_actions
+    def create
+      @course_of_action = CourseOfAction.new(course_of_action_params)
+
+      if @course_of_action.save
+        redirect_to @course_of_action, notice: 'Course of action was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /course_of_actions/1
+    def update
+      if @course_of_action.update(course_of_action_params)
+        redirect_to @course_of_action, notice: 'Course of action was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /course_of_actions/1
+    def destroy
+      @course_of_action.destroy
+      redirect_to course_of_actions_url, notice: 'Course of action was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_course_of_action
+        @course_of_action = CourseOfAction.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def course_of_action_params
+        params.require(:course_of_action).permit(:active_stix_id, :name, :description, :x_mitre_version)
+      end
+  end
+end

data/app/controllers/active_stix/cyber_observables_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class CyberObservablesController < ApplicationController
+    before_action :set_cyber_observable, only: [:show, :edit, :update, :destroy]
+
+    # GET /cyber_observables
+    def index
+      @cyber_observables = CyberObservable.all
+    end
+
+    # GET /cyber_observables/1
+    def show
+    end
+
+    # GET /cyber_observables/new
+    def new
+      @cyber_observable = CyberObservable.new
+    end
+
+    # GET /cyber_observables/1/edit
+    def edit
+    end
+
+    # POST /cyber_observables
+    def create
+      @cyber_observable = CyberObservable.new(cyber_observable_params)
+
+      if @cyber_observable.save
+        redirect_to @cyber_observable, notice: 'Cyber observable was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /cyber_observables/1
+    def update
+      if @cyber_observable.update(cyber_observable_params)
+        redirect_to @cyber_observable, notice: 'Cyber observable was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /cyber_observables/1
+    def destroy
+      @cyber_observable.destroy
+      redirect_to cyber_observables_url, notice: 'Cyber observable was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_cyber_observable
+        @cyber_observable = CyberObservable.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def cyber_observable_params
+        params.require(:cyber_observable).permit(:observed_datum_ref, :observable_object_id, :cyber_observable_object_type)
+      end
+  end
+end

data/app/controllers/active_stix/email_addresses_controller.rb

@@ -0,0 +1,74 @@
+class ActiveStix::EmailAddressesController < ApplicationController
+  before_action :set_stix_email_address, only: [:show, :edit, :update, :destroy]
+
+  # GET /stix/email_addresses
+  # GET /stix/email_addresses.json
+  def index
+    @email_addresses = ActiveStix::EmailAddress.all
+  end
+
+  # GET /stix/email_addresses/1
+  # GET /stix/email_addresses/1.json
+  def show
+  end
+
+  # GET /stix/email_addresses/new
+  def new
+    @email_address = ActiveStix::EmailAddress.new
+  end
+
+  # GET /stix/email_addresses/1/edit
+  def edit
+  end
+
+  # POST /stix/email_addresses
+  # POST /stix/email_addresses.json
+  def create
+    @email_address = ActiveStix::EmailAddress.new(stix_email_address_params)
+
+    respond_to do |format|
+      if @email_address.save
+        format.html { redirect_to @email_address, notice: 'Email address was successfully created.' }
+        format.json { render :show, status: :created, location: @email_address }
+      else
+        format.html { render :new }
+        format.json { render json: @email_address.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /stix/email_addresses/1
+  # PATCH/PUT /stix/email_addresses/1.json
+  def update
+    respond_to do |format|
+      if @email_address.update(stix_email_address_params)
+        format.html { redirect_to @email_address, notice: 'Email address was successfully updated.' }
+        format.json { render :show, status: :ok, location: @email_address }
+      else
+        format.html { render :edit }
+        format.json { render json: @email_address.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /stix/email_addresses/1
+  # DELETE /stix/email_addresses/1.json
+  def destroy
+    @email_address.destroy
+    respond_to do |format|
+      format.html { redirect_to stix_email_addresses_url, notice: 'Email address was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_stix_email_address
+      @email_address = ActiveStix::EmailAddress.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def stix_email_address_params
+      params.require(:email_address).permit(:value, :display_name, :belongs_to_ref)
+    end
+end