arachni 0.4.7 → 1.0

data/lib/arachni/http/request/scope.rb

@@ -0,0 +1,30 @@
+=begin
+    Copyright 2010-2014 Tasos Laskos <tasos.laskos@arachni-scanner.com>
+
+    This file is part of the Arachni Framework project and is subject to
+    redistribution and commercial restrictions. Please see the Arachni Framework
+    web site for more information on licensing and terms of use.
+=end
+
+module Arachni
+module HTTP
+class Request
+
+# Determines the {Scope scope} status of {Request}s.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@arachni-scanner.com>
+class Scope < Message::Scope
+
+    # {Scope} error namespace.
+    #
+    # All {Scope} errors inherit from and live under it.
+    #
+    # @author Tasos "Zapotek" Laskos <tasos.laskos@arachni-scanner.com>
+    class Error < Message::Scope::Error
+    end
+
+end
+
+end
+end
+end

data/lib/arachni/http/response.rb

@@ -0,0 +1,226 @@
+=begin
+    Copyright 2010-2014 Tasos Laskos <tasos.laskos@arachni-scanner.com>
+
+    This file is part of the Arachni Framework project and is subject to
+    redistribution and commercial restrictions. Please see the Arachni Framework
+    web site for more information on licensing and terms of use.
+=end
+
+module Arachni
+module HTTP
+
+# HTTP Response representation.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@arachni-scanner.com>
+class Response < Message
+    require_relative 'response/scope'
+
+    # @return   [Integer]
+    #   HTTP response status code.
+    attr_accessor :code
+
+    # @return   [String]
+    #   IP address of the server.
+    attr_accessor :ip_address
+
+    # @return   [String]
+    #   HTTP response status message.
+    attr_accessor :message
+
+    # @return   [Request]
+    #   HTTP {Request} which triggered this {Response}.
+    attr_accessor :request
+
+    # @return   [Array<Response>]
+    #   Automatically followed redirections that eventually led to this response.
+    attr_accessor :redirections
+
+    # @return   [Symbol]
+    #   `libcurl` return code.
+    attr_accessor :return_code
+
+    # @return   [String]
+    #   `libcurl` return code.
+    attr_accessor :return_message
+
+    # @return   [String]
+    #   Raw headers.
+    attr_accessor :headers_string
+
+    # @return   [Float]
+    #   Total time in seconds for the transfer, including name resolving, TCP
+    #   connect etc.
+    attr_accessor :total_time
+
+    # @return   [Float]
+    #   Time, in seconds, it took from the start until the full response was
+    #   received.
+    attr_accessor :time
+
+    # @return   [Float]
+    #   Approximate time the web application took to process the {#request}.
+    attr_accessor :app_time
+
+    def initialize( options = {} )
+        super( options )
+
+        @body ||= ''
+        @code ||= 0
+
+        # Holds the redirection responses that eventually led to this one.
+        @redirections ||= []
+    end
+
+    # @return   [Platform]
+    #   Applicable platforms for the page.
+    def platforms
+        Platform::Manager[url]
+    end
+
+    # @return   [String]
+    #   First line of the response.
+    def status_line
+        return if !headers_string
+        @status_line ||= headers_string.lines.first.to_s.chomp.freeze
+    end
+
+    # @return   [String]
+    #   HTTP response string.
+    def to_s
+        "#{headers_string}#{body}"
+    end
+
+    # @return [Boolean]
+    #   `true` if the response is a `3xx` redirect **and** there is a `Location`
+    #   header field.
+    def redirect?
+        code >= 300 && code <= 399 && !!headers.location
+    end
+    alias :redirection? :redirect?
+
+    def headers_string=( string )
+        @headers_string = string.freeze
+    end
+
+    # @note Depends on the response code.
+    #
+    # @return [Boolean]
+    #   `true` if the remote resource has been modified since the date given in
+    #   the `If-Modified-Since` request header field, `false` otherwise.
+    def modified?
+        code != 304
+    end
+
+    # @return [Bool]
+    #   `true` if the response body is textual in nature, `false` if binary,
+    #   `nil` if could not be determined.
+    def text?
+        return if !@body
+
+        if (type = headers.content_type)
+            return true if type.start_with?( 'text/' )
+
+            # Non "text/" nor "application/" content types will surely not be
+            # text-based so bail out early.
+            return false if !type.start_with?( 'application/' )
+        end
+
+        # Last resort, more resource intensive binary detection.
+        begin
+            !@body.binary?
+        rescue ArgumentError
+            nil
+        end
+    end
+
+    # @return   [Boolean]
+    #   `true` if timed out, `false` otherwise.
+    def timed_out?
+        [:operation_timedout, :couldnt_connect].include? return_code
+    end
+
+    def body=( body )
+        @body = body.to_s.dup
+
+        text_check = text?
+        @body.recode! if text_check.nil? || text_check
+
+        @body.freeze
+    end
+
+    # @return [Arachni::Page]
+    def to_page
+        Page.from_response self
+    end
+
+    # @return   [Hash]
+    def to_h
+        hash = {}
+        instance_variables.each do |var|
+            hash[var.to_s.gsub( /@/, '' ).to_sym] = instance_variable_get( var )
+        end
+
+        hash[:headers] = {}.merge( hash[:headers] )
+
+        hash.delete( :scope )
+        hash.delete( :parsed_url )
+        hash.delete( :redirections )
+        hash.delete( :request )
+        hash.delete( :scope )
+
+        hash
+    end
+
+    # @return   [Hash]
+    #   Data representing this instance that are suitable the RPC transmission.
+    def to_rpc_data
+        data = to_h
+        data[:request] = request.to_rpc_data
+        data.stringify_keys(false)
+    end
+
+    # @param    [Hash]  data    {#to_rpc_data}
+    # @return   [Request]
+    def self.from_rpc_data( data )
+        data['request']     = Request.from_rpc_data( data['request'] )
+        data['return_code'] = data['return_code'].to_sym if data['return_code']
+        new data
+    end
+
+    def ==( other )
+        hash == other.hash
+    end
+
+    def hash
+        to_h.hash
+    end
+
+    def self.from_typhoeus( response )
+        redirections = response.redirections.map do |redirect|
+            new(
+                url:     redirect.headers['Location'] || response.effective_url,
+                code:    redirect.code,
+                headers: redirect.headers
+            )
+        end
+
+        new(
+            url:            response.effective_url,
+            code:           response.code,
+            ip_address:     response.primary_ip,
+            headers:        response.headers,
+            headers_string: response.response_headers,
+            body:           response.body,
+            redirections:   redirections,
+            time:           response.time,
+            app_time:       response.timed_out? ? response.time :
+                                response.start_transfer_time - response.pretransfer_time,
+            total_time:     response.total_time,
+            return_code:    response.return_code,
+            return_message: response.return_message
+        )
+    end
+
+end
+end
+end

data/lib/arachni/http/response/scope.rb

@@ -0,0 +1,67 @@
+=begin
+    Copyright 2010-2014 Tasos Laskos <tasos.laskos@arachni-scanner.com>
+
+    This file is part of the Arachni Framework project and is subject to
+    redistribution and commercial restrictions. Please see the Arachni Framework
+    web site for more information on licensing and terms of use.
+=end
+
+module Arachni
+module HTTP
+class Response
+
+# Determines the {Scope scope} status of {Response}s.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@arachni-scanner.com>
+class Scope < Message::Scope
+
+    # {Scope} error namespace.
+    #
+    # All {Scope} errors inherit from and live under it.
+    #
+    # @author Tasos "Zapotek" Laskos <tasos.laskos@arachni-scanner.com>
+    class Error < Message::Scope::Error
+    end
+
+    # @param    [Arachni::HTTP::Response]  response
+    def initialize( response )
+        super response
+
+        @response = response
+    end
+
+    # @note Also takes into account the {URI::Scope} of the {Message#url}.
+    #
+    # @return   [Bool]
+    #   `true` if the {Response} is out of {OptionGroups::Scope scope},
+    #   `false` otherwise.
+    #
+    # @see #exclude_content?
+    # @see #exclude_as_binary?
+    def out?
+        super || exclude_as_binary? || exclude_content?
+    end
+
+    # @return   [Bool]
+    #   `true` if {OptionGroups::Scope#exclude_binaries?} and not {Response#text?},
+    #   `false` otherwise.
+    #
+    # @see OptionGroups::Scope#exclude_binaries
+    def exclude_as_binary?
+        options.exclude_binaries? && !@response.text?
+    end
+
+    # @return   [Bool]
+    #   `true` if {Message#body} matches an
+    #   {OptionGroups::Scope#exclude_content_patterns} pattern, `false` otherwise.
+    #
+    # @see OptionGroups::Scope#exclude_content_patterns
+    def exclude_content?
+        !!options.exclude_content_patterns.find { |i| @response.body =~ i }
+    end
+
+end
+
+end
+end
+end

data/lib/arachni/issue.rb

@@ -1,196 +1,155 @@
 =begin
-    Copyright 2010-2014 Tasos Laskos <tasos.laskos@gmail.com>
+    Copyright 2010-2014 Tasos Laskos <tasos.laskos@arachni-scanner.com>
 
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
+    This file is part of the Arachni Framework project and is subject to
+    redistribution and commercial restrictions. Please see the Arachni Framework
+    web site for more information on licensing and terms of use.
 =end
 
-require 'digest/sha2'
-
 module Arachni
 
-#
+require Options.paths.lib + 'issue/severity'
+
 # Represents a detected issue.
 #
-# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
-#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@arachni-scanner.com>
 class Issue
 
-    # Holds constants to describe the {Issue#severity} of an Issue.
-    module Severity
-        HIGH          = 'High'
-        MEDIUM        = 'Medium'
-        LOW           = 'Low'
-        INFORMATIONAL = 'Informational'
-    end
+    # Attributes removed from a parent issue (i.e. an issues with variations)
+    # and solely populating variations.
+    VARIATION_ATTRIBUTES = Set.new([
+        :@page, :@referring_page, :@proof, :@signature, :@remarks, :@trusted
+    ])
 
-    # @return    [String]   The name of the issue.
+    # @return    [String]
+    #   Name.
     attr_accessor :name
 
-    # @return    [String]   The module that detected the issue.
-    attr_accessor :mod_name
-
-    # @return    [Symbol]   Name of the vulnerable platform.
-    # @see Platform::Manager
-    attr_accessor :platform
-
-    # @return    [Symbol]   Type of the vulnerable platform.
-    # @see Platform::Manager
-    attr_accessor :platform_type
-
-    # @return    [String]   The name of the vulnerable input.
-    attr_accessor :var
-
-    # @return    [String]   URL of the vulnerable resource.
-    attr_accessor :url
-
-    # @return [Hash<Symbol, Hash>]  `:request` and `:response` HTTP headers.
-    attr_accessor :headers
-
-    # @return [String]  The html response of the attack.
-    attr_accessor :response
-
-    # @return    [String]   The injected seed that revealed the issue.
-    attr_accessor :injected
-
-    # @return    [String]   The string that verified the issue.
-    attr_accessor :id
-
-    # @return    [String]   The regexp that identified the issue.
-    attr_reader   :regexp
-
-    # @return    [String]   The data that was matched by the regexp.
-    attr_accessor :regexp_match
-
-    # @return    [String]   Type of the vulnerable type.
-    # @see Module::Auditor::OPTIONS
-    attr_accessor :elem
-
-    # @return    [String]   HTTP method used.
-    attr_accessor :method
-
-    # @return    [String]   Brief description of the issue.
+    # @note Should be treated as Markdown.
+    #
+    # @return    [String]
+    #   Brief description.
     attr_accessor :description
 
-    # @return    [Hash]     References related to the issue.
-    attr_accessor :references
-
-    # @return    [String]   The CWE ID number of the issue.
-    # @see http://cwe.mitre.org/
-    attr_accessor :cwe
+    # @note Should be treated as Markdown.
+    #
+    # @return    [String]
+    #   Brief text explaining how to remedy the issue.
+    attr_accessor :remedy_guidance
 
-    # @return    [String]   CWE URL of the issue
-    # @see #cwe
-    # @see http://cwe.mitre.org/
-    attr_accessor :cwe_url
+    # @return    [String]
+    #   Code snippet demonstrating how to remedy the Issue.
+    attr_accessor :remedy_code
 
-    # @return    [String]   Severity of the issue.
+    # @return    [String]
+    #   Severity of the issue.
+    #
     # @see Severity
     attr_accessor :severity
 
-    # @return    [String]   The CVSS v2 score.
-    # @see http://nvd.nist.gov/cvss.cfm
-    attr_accessor :cvssv2
+    # @return [Array<String>]
+    #   Tags categorizing the issue.
+    attr_accessor :tags
 
-    # @return    [String]
-    #   A brief text informing the user how to remedy the Issue.
-    attr_accessor :remedy_guidance
+    # @return    [Hash]
+    #   References related to the issue.
+    attr_accessor :references
 
     # @return    [String]
-    #   A code snippet showing the user how to remedy the Issue.
-    attr_accessor :remedy_code
-
+    #   The CWE ID number of the issue.
     #
-    # Placeholder variable to be populated by {AuditStore#prepare_variations}
-    #
-    # @return   [Array<Issue>]  Variations of this issue.
+    # @see http://cwe.mitre.org/
+    attr_accessor :cwe
+
+    # @return    [Symbol]
+    #   Name of the vulnerable platform.
     #
-    # @see AuditStore#prepare_variations
+    # @see Platform::Manager
+    attr_accessor :platform_name
+
+    # @return    [Symbol]
+    #   Type of the vulnerable platform.
     #
-    attr_accessor :variations
+    # @see Platform::Manager
+    attr_accessor :platform_type
 
-    # @return  [Bool]   Is manual verification required?
-    attr_accessor :verification
+    # @return    [Element::Base, nil]
+    #   Instance of the relevant vector if available.
+    attr_accessor :vector
 
-    # @return  [String]
-    #   The Metasploit module that can exploit the vulnerability.
-    attr_accessor :metasploitable
+    # @return   [Page]
+    #   Page containing the {#vector} and whose audit resulted in the discovery
+    #   of the issue.
+    attr_accessor :referring_page
 
-    # @return [Hash]    Audit options associated with the issue.
-    attr_reader   :opts
+    # @return   [Page]
+    #   Page proving the issue.
+    attr_accessor :page
 
-    attr_accessor :internal_modname
+    # @return   [Hash]
+    #   {Check::Base.info Information} about the check that logged the issue.
+    attr_accessor :check
 
-    # @return [Array<String>]   Tags categorizing the issue.
-    attr_accessor :tags
+    # @return    [String]
+    #   The signature/pattern that identified the issue.
+    attr_accessor :signature
+
+    # @return    [String]
+    #   Data that was matched by the {#signature}.
+    attr_accessor :proof
+
+    # @return   [Bool]
+    #   `true` if the issue can be trusted (doesn't require manual verification),
+    #   `false` otherwise.
+    attr_accessor :trusted
 
     # @return [Hash]
     #   Remarks about the issue. Key is the name of the entity which
     #   made the remark, value is an `Array` of remarks.
     attr_accessor :remarks
 
-    #
-    # Sets up the instance attributes.
-    #
-    # @param    [Hash]    opts
-    #   Configuration hash. The returned data of a module's {Module::Base.info}
-    #   method merged with a `Hash` holding {Issue} attributes.
-    #
-    def initialize( opts = {} )
-        # Make sure we're dealing with UTF-8 data.
-        opts = opts.recode
-
-        @verification = false
-        @references   = {}
-        @opts         = { regexp: '' }
-
-        opts.each do |k, v|
-            send( "#{k.to_s.downcase}=", encode( v ) ) rescue nil
-        end
-
-        opts[:regexp] = opts[:regexp].to_s if opts[:regexp]
-        opts[:issue].each do |k, v|
-            send( "#{k.to_s.downcase}=", encode( v ) ) rescue nil
-        end if opts[:issue]
+    # @return   [Array<Issue>]
+    #   Variations of this issue.
+    attr_accessor :variations
 
-        @headers ||= {}
-        if opts[:headers] && opts[:headers][:request]
-            @headers[:request] = {}.merge( opts[:headers][:request] )
-        end
-        @headers[:request] ||= {}
+    # @param    [Hash]    options
+    #   Configuration hash holding instance attributes.
+    def initialize( options = {} )
+        # Make sure we're dealing with UTF-8 data.
+        options = options.recode
 
-        if opts[:headers] && opts[:headers][:response]
-            @headers[:response] = {}.merge( opts[:headers][:response] )
+        options.each do |k, v|
+            send( "#{k.to_s.downcase}=", v )
         end
-        @headers[:response] ||= {}
 
-        @response ||= ''
+        fail ArgumentError, 'Missing :vector' if !@vector
 
-        @method   = @method.to_s.upcase
-        @mod_name = opts[:name]
+        @remarks    ||= {}
+        @trusted      = true if @trusted.nil?
+        @references ||= {}
+        @tags       ||= []
+        @variations ||= []
+        @variation    = nil
+    end
 
-        @remarks ||= {}
+    # @return   [HTTP::Response]
+    def response
+        return if !page
+        page.response
+    end
 
-        # remove this block because it won't be able to be serialized
-        @opts.delete( :each_mutation )
-        @tags ||= []
+    # @return   [HTTP::Request]
+    def request
+        return if !response
+        response.request
     end
 
-    #
     # Adds a remark as a heads-up to the end user.
     #
-    # @param    [String, Symbol]    author  Component which made the remark.
-    # @param    [String]    string  Remark.
-    #
+    # @param    [String, Symbol]    author
+    #   Component which made the remark.
+    # @param    [String]    string
+    #   Remark.
     def add_remark( author, string )
         fail ArgumentError, 'Author cannot be blank.' if author.to_s.empty?
         fail ArgumentError, 'String cannot be blank.' if string.to_s.empty?
@@ -202,32 +161,35 @@ class Issue
     #   `true` if the issue was discovered by manipulating an input,
     #   `false` otherwise.
     #
-    # @see recon?
-    #
-    def audit?
-        !!@var
+    # @see #passive?
+    def active?
+        if variations && variations.any?
+            return variations.first.active?
+        end
+
+        !!(vector.respond_to?( :affected_input_name ) && vector.affected_input_name)
     end
 
-    # @return   [Boolean]
-    #   `true` if the issue was discovered passively, `false` otherwise.
+    # @return   [String, nil]
+    #   The name of the affected input, `nil` if the issue is {#passive?}.
     #
-    # @see audit?
-    #
-    def recon?
-        !audit?
-    end
+    # @see #passive?
+    def affected_input_name
+        return if !active?
+
+        if variations && variations.any?
+            return variations.first.vector.affected_input_name
+        end
 
-    # @see #regexp_match
-    def match
-        self.regexp_match
+        vector.affected_input_name
     end
 
-    # @return   [Bool]
-    #   `true` if the issue requires manual verification, `false` otherwise.
+    # @return   [Boolean]
+    #   `true` if the issue was discovered passively, `false` otherwise.
     #
-    # @see #verification
-    def requires_verification?
-        !!@verification
+    # @see audit?
+    def passive?
+        !active?
     end
 
     # @return   [Bool]
@@ -236,7 +198,7 @@ class Issue
     #
     # @see #requires_verification?
     def trusted?
-        !requires_verification?
+        !!@trusted
     end
 
     # @see #trusted?
@@ -244,87 +206,207 @@ class Issue
         !trusted?
     end
 
-    def url=( v )
-        @url = Utilities.normalize_url( v )
-
-        # Last resort sanitization.
-        @url = v.split( '?' ).first if @url.to_s.empty?
-        @url
+    def cwe=( id )
+        id = id.to_i
+        return if id == 0
+        @cwe = id
     end
 
-    def cwe=( v )
-        return if !v || v.to_s.empty?
-        @cwe = v.to_s
-        @cwe_url = "http://cwe.mitre.org/data/definitions/#{@cwe}.html"
-        @cwe
+    # @return   [String]
+    #   {#cwe CWE} reference URL.
+    def cwe_url
+        return if !cwe
+        @cwe_url ||= "http://cwe.mitre.org/data/definitions/#{cwe}.html".freeze
     end
 
     def references=( refs )
-        @references = refs || {}
+        @references = (refs || {}).stringify_recursively_and_freeze
     end
 
-    def regexp=( regexp )
-        @regexp = regexp.to_s
-    end
+    [:page, :referring_page, :vector].each do |m|
+        define_method "#{m}=" do |object|
+            if object
+                # Once the object is logged we need a deep copy of it to ensure
+                # integrity.
+                object = object.deep_clone
+                object.prepare_for_report
+            end
 
-    def opts=( hash )
-        if !hash
-            @opts = { regexp: '' }
-            return
+            instance_variable_set( "@#{m}".to_sym, object )
         end
-        hash[:regexp] = hash[:regexp].to_s
-        @opts = hash.dup
-    end
-
-    def []( k )
-        send( "#{k}" )
-    rescue
-        instance_variable_get( "@#{k.to_s}".to_sym )
     end
 
-    def []=( k, v )
-        v = encode( v )
-        begin
-            send( "#{k.to_s}=", v )
-        rescue
-            instance_variable_set( "@#{k.to_s}".to_sym, v )
+    [:name, :description, :remedy_guidance, :remedy_code, :proof, :signature].each do |m|
+        define_method "#{m}=" do |s|
+            instance_variable_set( "@#{m}".to_sym, s ? s.to_s.freeze : nil )
         end
     end
 
-    def each( &block )
-        to_h.each( &block )
-    end
-
-    def each_pair( &block )
-        to_h.each_pair( &block )
-    end
-
     # @return   [Hash]
     def to_h
         h = {}
+
         self.instance_variables.each do |var|
-            h[normalize_name( var )] = instance_variable_get( var )
+            h[normalize_name( var )] = try_dup( instance_variable_get( var ) )
+        end
+
+        h[:vector] = vector.to_h
+        h.delete( :unique_id )
+
+        if solo?
+            h.delete( :variation )
+        else
+            if variation?
+                h[:vector].delete :html
+                h[:vector].delete :type
+                h[:vector].delete :url
+                h[:vector].delete :action
+                h[:vector].delete :default_inputs
+                h[:vector].delete :affected_input_name
+            else
+                h[:vector][:inputs] = h[:vector].delete( :default_inputs )
+                h[:vector][:affected_input_name] = affected_input_name
+            end
+        end
+
+        if !variation? || solo?
+            h[:digest]   = digest
+            h[:severity] = severity.to_sym
+            h[:cwe_url]  = cwe_url if cwe_url
+
+            # Since we're doing the whole cross-platform hash thing better switch
+            # the Element classes in the check's info data to symbols.
+            h[:check][:elements] ||= []
+            h[:check][:elements]   = h[:check][:elements].map(&:type)
+
+            h[:variations] = @variations.map(&:to_h)
+        end
+
+        if variation? || solo?
+            if page
+                dom_h = page.dom.to_h
+                dom_h.delete(:skip_states)
+
+                h[:page] = {
+                    body: page.body,
+                    dom:  dom_h
+                }
+            end
+
+            if referring_page
+                referring_page_dom_h = referring_page.dom.to_h
+                referring_page_dom_h.delete(:skip_states)
+
+                h[:referring_page] = {
+                    body: referring_page.body,
+                    dom:  referring_page_dom_h
+                }
+            end
+
+            h[:response] = response.to_h if response
+            h[:request]  = request.to_h  if request
         end
-        h[:digest] = h[:_hash] = digest
-        h[:hash]  = hash
-        h[:unique_id] = unique_id
+
         h
     end
     alias :to_hash :to_h
 
-    # @return   [String]    A string uniquely identifying this issue.
+    # @return   [String]
+    #   A string uniquely identifying this issue.
     def unique_id
-        "#{@mod_name}::#{@elem}::#{@var}::#{@url.split( '?' ).first}"
+        return @unique_id if @unique_id
+        vector_info = active? ? "#{vector.method}:#{vector.affected_input_name}:" : nil
+        "#{name}:#{vector_info}#{vector.action.split( '?' ).first}"
     end
 
-    # @return   [String]
-    #   A SHA2 hash (of {#unique_id}) uniquely identifying this issue.
+    # @return   [Integer]
+    #   A hash uniquely identifying this issue.
     #
     # @see #unique_id
     def digest
-        Digest::SHA2.hexdigest( unique_id )
+        unique_id.persistent_hash
+    end
+
+    # @return   [Bool]
+    #   `true` if the issue neither has nor is a variation, `false` otherwise.
+    def solo?
+        @variation.nil?
+    end
+
+    # @return   [Bool]
+    #   `true` if `self` is a variation.
+    def variation?
+        !!@variation
+    end
+
+    # @return   [Issue]
+    #   A copy of `self` **without** {VARIATION_ATTRIBUTES specific} details
+    #   and an empty array of {#variations} to be populated.
+    #
+    #   Also, the {#vector} attribute will hold the original, non-mutated vector.
+    def with_variations
+        issue = self.deep_clone
+
+        instance_variables.each do |k|
+            next if k == :@trusted || !VARIATION_ATTRIBUTES.include?( k ) ||
+                !issue.instance_variable_defined?( k )
+
+            issue.remove_instance_variable k
+        end
+
+        issue.vector.reset
+
+        issue.unique_id = unique_id
+        issue.variation = false
+        issue
+    end
+
+    # @return   [Issue]
+    #   A copy of `self` with {VARIATION_ATTRIBUTES specific} details **only**
+    #   and the mutated {#vector}.
+    def as_variation
+        issue = self.deep_clone
+
+        instance_variables.each do |k|
+            next if k == :@vector || VARIATION_ATTRIBUTES.include?( k ) ||
+                !issue.instance_variable_defined?( k )
+
+            issue.remove_instance_variable k
+        end
+
+        issue.unique_id = unique_id
+        issue.variation = true
+        issue
+    end
+
+    # Converts `self` to a solo issue, in place.
+    #
+    # @param    [Issue] issue
+    #   Parent issue.
+    # @return   [Issue]
+    #   Solo issue, with generic vulnerability data filled in from `issue`.
+    def to_solo!( issue )
+        issue.instance_variables.each do |k|
+            next if k == :@variations || k == :@vector || k == :@trusted
+            next if (val = issue.instance_variable_get(k)).nil?
+            instance_variable_set( k, val )
+        end
+
+        @variations = []
+        @variation  = nil
+
+        self
+    end
+
+    # Copy of `self` as a solo issue.
+    #
+    # @param    [Issue] issue
+    #   Parent issue.
+    # @return   [Issue]
+    #   Solo issue, with generic vulnerability data filled in from `issue`.
+    def to_solo( issue )
+        deep_clone.to_solo!( issue )
     end
-    alias :_hash :digest
 
     def ==( other )
         hash == other.hash
@@ -338,21 +420,105 @@ class Issue
         hash == other.hash
     end
 
-    def remove_instance_var( var )
-        remove_instance_variable( var )
+    # @return   [Hash]
+    #   Data representing this instance that are suitable the RPC transmission.
+    def to_rpc_data
+        data = {}
+        instance_variables.each do |ivar|
+            data[ivar.to_s.gsub('@','')] = instance_variable_get( ivar ).to_rpc_data_or_self
+        end
+
+
+        if data['check'] && data['check'][:elements]
+            data['check'] = data['check'].dup
+            data['check'][:elements] = data['check'][:elements].map(&:to_s)
+        end
+
+        if data['variations']
+            data['variations'] = data['variations'].map(&:to_rpc_data)
+        end
+
+        data['digest']   = digest
+        data['severity'] = data['severity'].to_s
+
+        data
     end
 
-    private
+    # @param    [Hash]  data
+    #   {#to_rpc_data}
+    # @return   [Issue]
+    def self.from_rpc_data( data )
+        instance = allocate
+
+        data.each do |name, value|
+            value = case name
+                        when 'vector'
+                            element_string_to_class( value.delete('class') ).from_rpc_data( value )
 
-    def encode( str )
-        return str if !str.is_a?( String )
-        str.recode
+                        when 'check'
+                            if value['elements']
+                                value['elements'] = (value['elements'].map do |class_name|
+                                    element_string_to_class( class_name )
+                                end)
+                            end
+
+                            value.symbolize_keys(false)
+
+                        when 'variations'
+                            value.map { |i| from_rpc_data i }
+
+                        when 'remarks'
+                            value.symbolize_keys
+
+                        when 'platform_name', 'platform_type'
+                            next if !value
+                            value.to_sym
+
+                        when 'severity'
+                            next if value.to_s.empty?
+                            Severity.const_get( value.upcase.to_sym )
+
+                        when 'page', 'referring_page'
+                            Arachni::Page.from_rpc_data( value )
+
+                        else
+                            value
+                    end
+
+            instance.instance_variable_set( "@#{name}", value )
+        end
+        instance
     end
 
+    protected
+
+    def self.element_string_to_class( element )
+        parent = Arachni::Element
+        element.gsub( "#{parent}::", '' ).split( '::' ).each do |klass|
+            parent = parent.const_get( klass )
+        end
+        parent
+    end
+
+    def unique_id=( id )
+        @unique_id = id
+    end
+
+    def variation=( bool )
+        @variation = bool
+    end
+
+    private
+
     def normalize_name( name )
-        name.to_s.gsub( /@/, '' )
+        name.to_s.gsub( /@/, '' ).to_sym
+    end
+
+    def try_dup( obj )
+        obj.dup rescue obj
     end
 
+    protected :remove_instance_variable
 end
 end