diff --git a/lib/facter/facts/aix/ssh.rb b/lib/facter/facts/aix/ssh.rb
index b3475009f3..751712e6aa 100644
--- a/lib/facter/facts/aix/ssh.rb
+++ b/lib/facter/facts/aix/ssh.rb
@@ -4,30 +4,21 @@ module Facts
   module Aix
     class Ssh
       FACT_NAME = 'ssh'
-      ALIASES = %w[ssh.*key sshfp_.*].freeze
 
       def call_the_resolver
-        resolved_facts = []
-        resolver_data = Facter::Resolvers::SshResolver.resolve(:ssh)
-
-        fact_value = extract_fact(resolver_data)
-
-        resolved_facts.push(Facter::ResolvedFact.new(FACT_NAME, fact_value))
-
-        resolver_data.each do |ssh_data|
-          resolved_facts.push(build_key_data(ssh_data))
-          resolved_facts.push(build_fp_data(ssh_data))
-        end
-
-        resolved_facts
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
 
       private
 
-      def extract_fact(resolver_data)
+      def fact_value
         resolver_data.map { |el| create_ssh_fact(el) }.inject(:merge)
       end
 
+      def resolver_data
+        Facter::Resolvers::SshResolver.resolve(:ssh)
+      end
+
       def create_ssh_fact(ssh)
         return {} unless ssh
 
@@ -40,20 +31,6 @@ def create_ssh_fact(ssh)
           type: ssh.type
         } }
       end
-
-      def build_key_data(ssh_data)
-        fact_name = "ssh#{ssh_data.name}key"
-        fact_value = ssh_data.key
-
-        Facter::ResolvedFact.new(fact_name, fact_value, :legacy)
-      end
-
-      def build_fp_data(ssh_data)
-        fact_name = "sshfp_#{ssh_data.name}"
-        fact_value = "#{ssh_data.fingerprint.sha1}\n#{ssh_data.fingerprint.sha256}"
-
-        Facter::ResolvedFact.new(fact_name, fact_value, :legacy)
-      end
     end
   end
 end
diff --git a/lib/facter/facts/aix/sshalgorithmkey.rb b/lib/facter/facts/aix/sshalgorithmkey.rb
new file mode 100644
index 0000000000..dca2887e0b
--- /dev/null
+++ b/lib/facter/facts/aix/sshalgorithmkey.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    class Sshalgorithmkey
+      FACT_NAME = 'ssh.*key'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
+        facts
+      end
+    end
+  end
+end
diff --git a/lib/facter/facts/aix/sshfp_algorithm.rb b/lib/facter/facts/aix/sshfp_algorithm.rb
new file mode 100644
index 0000000000..3f68869ef1
--- /dev/null
+++ b/lib/facter/facts/aix/sshfp_algorithm.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    class SshfpAlgorithm
+      FACT_NAME = 'sshfp_.*'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result.each do |ssh|
+          facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
+                                            "#{ssh.fingerprint.sha1} \n #{ssh.fingerprint.sha256}", :legacy)
+        end
+        facts
+      end
+    end
+  end
+end
diff --git a/lib/facter/facts/freebsd/ssh.rb b/lib/facter/facts/freebsd/ssh.rb
index 2f3e6660cf..60ab91895d 100644
--- a/lib/facter/facts/freebsd/ssh.rb
+++ b/lib/facter/facts/freebsd/ssh.rb
@@ -4,55 +4,22 @@ module Facts
   module Freebsd
     class Ssh
       FACT_NAME = 'ssh'
-      ALIASES = %w[ssh.*key sshfp_.*].freeze
 
       def call_the_resolver
-        resolved_facts = []
-        resolver_data = Facter::Resolvers::SshResolver.resolve(:ssh)
-
-        fact_value = extract_fact(resolver_data)
-
-        resolved_facts.push(Facter::ResolvedFact.new(FACT_NAME, fact_value))
-
-        resolver_data.each do |ssh_data|
-          resolved_facts.push(build_key_data(ssh_data))
-          resolved_facts.push(build_fp_data(ssh_data))
-        end
-
-        resolved_facts
+        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        ssh_facts = {}
+        result.each { |ssh| ssh_facts.merge!(create_ssh_fact(ssh)) }
+        Facter::ResolvedFact.new(FACT_NAME, ssh_facts)
       end
 
       private
 
-      def extract_fact(resolver_data)
-        resolver_data.map { |el| create_ssh_fact(el) }.inject(:merge)
-      end
-
       def create_ssh_fact(ssh)
-        return {} unless ssh
-
-        { ssh.name.to_sym => {
-          fingerprints: {
-            sha1: ssh.fingerprint.sha1,
-            sha256: ssh.fingerprint.sha256
-          },
-          key: ssh.key,
-          type: ssh.type
-        } }
-      end
-
-      def build_key_data(ssh_data)
-        fact_name = "ssh#{ssh_data.name}key"
-        fact_value = ssh_data.key
-
-        Facter::ResolvedFact.new(fact_name, fact_value, :legacy)
-      end
-
-      def build_fp_data(ssh_data)
-        fact_name = "sshfp_#{ssh_data.name}"
-        fact_value = "#{ssh_data.fingerprint.sha1}\n#{ssh_data.fingerprint.sha256}"
-
-        Facter::ResolvedFact.new(fact_name, fact_value, :legacy)
+        { ssh.name.to_sym =>
+              { fingerprints: { sha1: ssh.fingerprint.sha1,
+                                sha256: ssh.fingerprint.sha256 },
+                key: ssh.key,
+                type: ssh.type } }
       end
     end
   end
diff --git a/lib/facter/facts/freebsd/sshalgorithmkey.rb b/lib/facter/facts/freebsd/sshalgorithmkey.rb
new file mode 100644
index 0000000000..a88fca90d6
--- /dev/null
+++ b/lib/facter/facts/freebsd/sshalgorithmkey.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facts
+  module Freebsd
+    class Sshalgorithmkey
+      FACT_NAME = 'ssh.*key'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
+        facts
+      end
+    end
+  end
+end
diff --git a/lib/facter/facts/freebsd/sshfp_algorithm.rb b/lib/facter/facts/freebsd/sshfp_algorithm.rb
new file mode 100644
index 0000000000..f8feb930dd
--- /dev/null
+++ b/lib/facter/facts/freebsd/sshfp_algorithm.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facts
+  module Freebsd
+    class SshfpAlgorithm
+      FACT_NAME = 'sshfp_.*'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result.each do |ssh|
+          facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
+                                            "#{ssh.fingerprint.sha1} \n #{ssh.fingerprint.sha256}", :legacy)
+        end
+        facts
+      end
+    end
+  end
+end
diff --git a/lib/facter/facts/linux/ssh.rb b/lib/facter/facts/linux/ssh.rb
index c003a4180a..e462e4eb1c 100644
--- a/lib/facter/facts/linux/ssh.rb
+++ b/lib/facter/facts/linux/ssh.rb
@@ -4,30 +4,21 @@ module Facts
   module Linux
     class Ssh
       FACT_NAME = 'ssh'
-      ALIASES = %w[ssh.*key sshfp_.*].freeze
 
       def call_the_resolver
-        resolved_facts = []
-        resolver_data = Facter::Resolvers::SshResolver.resolve(:ssh)
-
-        fact_value = extract_fact(resolver_data)
-
-        resolved_facts.push(Facter::ResolvedFact.new(FACT_NAME, fact_value))
-
-        resolver_data.each do |ssh_data|
-          resolved_facts.push(build_key_data(ssh_data))
-          resolved_facts.push(build_fp_data(ssh_data))
-        end
-
-        resolved_facts
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
 
       private
 
-      def extract_fact(resolver_data)
+      def fact_value
         resolver_data.map { |el| create_ssh_fact(el) }.inject(:merge)
       end
 
+      def resolver_data
+        Facter::Resolvers::SshResolver.resolve(:ssh)
+      end
+
       def create_ssh_fact(ssh)
         return {} unless ssh
 
@@ -40,20 +31,6 @@ def create_ssh_fact(ssh)
           type: ssh.type
         } }
       end
-
-      def build_key_data(ssh_data)
-        fact_name = "ssh#{ssh_data.name}key"
-        fact_value = ssh_data.key
-
-        Facter::ResolvedFact.new(fact_name, fact_value, :legacy)
-      end
-
-      def build_fp_data(ssh_data)
-        fact_name = "sshfp_#{ssh_data.name}"
-        fact_value = "#{ssh_data.fingerprint.sha1}\n#{ssh_data.fingerprint.sha256}"
-
-        Facter::ResolvedFact.new(fact_name, fact_value, :legacy)
-      end
     end
   end
 end
diff --git a/lib/facter/facts/macosx/ssh.rb b/lib/facter/facts/macosx/ssh.rb
index b1d8f2d770..7c2b5b88df 100644
--- a/lib/facter/facts/macosx/ssh.rb
+++ b/lib/facter/facts/macosx/ssh.rb
@@ -4,30 +4,21 @@ module Facts
   module Macosx
     class Ssh
       FACT_NAME = 'ssh'
-      ALIASES = %w[ssh.*key sshfp_.*].freeze
 
       def call_the_resolver
-        resolved_facts = []
-        resolver_data = Facter::Resolvers::SshResolver.resolve(:ssh)
-
-        fact_value = extract_fact(resolver_data)
-
-        resolved_facts.push(Facter::ResolvedFact.new(FACT_NAME, fact_value))
-
-        resolver_data.each do |ssh_data|
-          resolved_facts.push(build_key_data(ssh_data))
-          resolved_facts.push(build_fp_data(ssh_data))
-        end
-
-        resolved_facts
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
 
       private
 
-      def extract_fact(resolver_data)
+      def fact_value
         resolver_data.map { |el| create_ssh_fact(el) }.inject(:merge)
       end
 
+      def resolver_data
+        Facter::Resolvers::SshResolver.resolve(:ssh)
+      end
+
       def create_ssh_fact(ssh)
         return {} unless ssh
 
@@ -40,20 +31,6 @@ def create_ssh_fact(ssh)
           type: ssh.type
         } }
       end
-
-      def build_key_data(ssh_data)
-        fact_name = "ssh#{ssh_data.name}key"
-        fact_value = ssh_data.key
-
-        Facter::ResolvedFact.new(fact_name, fact_value, :legacy)
-      end
-
-      def build_fp_data(ssh_data)
-        fact_name = "sshfp_#{ssh_data.name}"
-        fact_value = "#{ssh_data.fingerprint.sha1}\n#{ssh_data.fingerprint.sha256}"
-
-        Facter::ResolvedFact.new(fact_name, fact_value, :legacy)
-      end
     end
   end
 end
diff --git a/lib/facter/facts/solaris/ssh.rb b/lib/facter/facts/solaris/ssh.rb
index a90a1aff67..062c3b6acc 100644
--- a/lib/facter/facts/solaris/ssh.rb
+++ b/lib/facter/facts/solaris/ssh.rb
@@ -4,30 +4,21 @@ module Facts
   module Solaris
     class Ssh
       FACT_NAME = 'ssh'
-      ALIASES = %w[ssh.*key sshfp_.*].freeze
 
       def call_the_resolver
-        resolved_facts = []
-        resolver_data = Facter::Resolvers::SshResolver.resolve(:ssh)
-
-        fact_value = extract_fact(resolver_data)
-
-        resolved_facts.push(Facter::ResolvedFact.new(FACT_NAME, fact_value))
-
-        resolver_data.each do |ssh_data|
-          resolved_facts.push(build_key_data(ssh_data))
-          resolved_facts.push(build_fp_data(ssh_data))
-        end
-
-        resolved_facts
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
 
       private
 
-      def extract_fact(resolver_data)
+      def fact_value
         resolver_data.map { |el| create_ssh_fact(el) }.inject(:merge)
       end
 
+      def resolver_data
+        Facter::Resolvers::SshResolver.resolve(:ssh)
+      end
+
       def create_ssh_fact(ssh)
         return {} unless ssh
 
@@ -40,20 +31,6 @@ def create_ssh_fact(ssh)
           type: ssh.type
         } }
       end
-
-      def build_key_data(ssh_data)
-        fact_name = "ssh#{ssh_data.name}key"
-        fact_value = ssh_data.key
-
-        Facter::ResolvedFact.new(fact_name, fact_value, :legacy)
-      end
-
-      def build_fp_data(ssh_data)
-        fact_name = "sshfp_#{ssh_data.name}"
-        fact_value = "#{ssh_data.fingerprint.sha1}\n#{ssh_data.fingerprint.sha256}"
-
-        Facter::ResolvedFact.new(fact_name, fact_value, :legacy)
-      end
     end
   end
 end
diff --git a/lib/facter/facts/solaris/sshalgorithmkey.rb b/lib/facter/facts/solaris/sshalgorithmkey.rb
new file mode 100644
index 0000000000..cf39a9d900
--- /dev/null
+++ b/lib/facter/facts/solaris/sshalgorithmkey.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    class Sshalgorithmkey
+      FACT_NAME = 'ssh.*key'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
+        facts
+      end
+    end
+  end
+end
diff --git a/lib/facter/facts/solaris/sshfp_algorithm.rb b/lib/facter/facts/solaris/sshfp_algorithm.rb
new file mode 100644
index 0000000000..9cb4d9bf0b
--- /dev/null
+++ b/lib/facter/facts/solaris/sshfp_algorithm.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    class SshfpAlgorithm
+      FACT_NAME = 'sshfp_.*'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result.each do |ssh|
+          facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
+                                            "#{ssh.fingerprint.sha1} \n #{ssh.fingerprint.sha256}", :legacy)
+        end
+        facts
+      end
+    end
+  end
+end
diff --git a/lib/facter/facts/windows/ssh.rb b/lib/facter/facts/windows/ssh.rb
index 92a893cfe4..54f65a715d 100644
--- a/lib/facter/facts/windows/ssh.rb
+++ b/lib/facter/facts/windows/ssh.rb
@@ -4,22 +4,13 @@ module Facts
   module Windows
     class Ssh
       FACT_NAME = 'ssh'
-      ALIASES = %w[ssh.*key sshfp_.*].freeze
 
       def call_the_resolver
-        resolved_facts = []
         privileged = Facter::Resolvers::Identity.resolve(:privileged)
         ssh_info = Facter::Resolvers::Windows::Ssh.resolve(:ssh) if privileged
         ssh_facts = {}
-
-        ssh_info&.each do |ssh_data|
-          ssh_facts.merge!(create_ssh_fact(ssh_data))
-          resolved_facts.push(build_key_data(ssh_data))
-          resolved_facts.push(build_fp_data(ssh_data))
-        end
-        resolved_facts.push(Facter::ResolvedFact.new(FACT_NAME, ssh_facts.empty? ? nil : ssh_facts))
-
-        resolved_facts
+        ssh_info&.each { |ssh| ssh_facts.merge!(create_ssh_fact(ssh)) }
+        Facter::ResolvedFact.new(FACT_NAME, ssh_facts.empty? ? nil : ssh_facts)
       end
 
       private
@@ -31,20 +22,6 @@ def create_ssh_fact(ssh)
                 key: ssh.key,
                 type: ssh.type } }
       end
-
-      def build_key_data(ssh_data)
-        fact_name = "ssh#{ssh_data.name}key"
-        fact_value = ssh_data.key
-
-        Facter::ResolvedFact.new(fact_name, fact_value, :legacy)
-      end
-
-      def build_fp_data(ssh_data)
-        fact_name = "sshfp_#{ssh_data.name}"
-        fact_value = "#{ssh_data.fingerprint.sha1}\n#{ssh_data.fingerprint.sha256}"
-
-        Facter::ResolvedFact.new(fact_name, fact_value, :legacy)
-      end
     end
   end
 end
diff --git a/lib/facter/facts/windows/sshalgorithmkey.rb b/lib/facter/facts/windows/sshalgorithmkey.rb
new file mode 100644
index 0000000000..f49473cde3
--- /dev/null
+++ b/lib/facter/facts/windows/sshalgorithmkey.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class Sshalgorithmkey
+      FACT_NAME = 'ssh.*key'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        privileged = Facter::Resolvers::Identity.resolve(:privileged)
+
+        return facts unless privileged
+
+        result = Facter::Resolvers::Windows::Ssh.resolve(:ssh)
+
+        result&.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
+        facts
+      end
+    end
+  end
+end
diff --git a/lib/facter/facts/windows/sshfp_algorithm.rb b/lib/facter/facts/windows/sshfp_algorithm.rb
new file mode 100644
index 0000000000..93ec59add6
--- /dev/null
+++ b/lib/facter/facts/windows/sshfp_algorithm.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class SshfpAlgorithm
+      FACT_NAME = 'sshfp_.*'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        privileged = Facter::Resolvers::Identity.resolve(:privileged)
+
+        return facts unless privileged
+
+        result = Facter::Resolvers::Windows::Ssh.resolve(:ssh)
+
+        result&.each do |ssh|
+          facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
+                                            "#{ssh.fingerprint.sha1} \n #{ssh.fingerprint.sha256}", :legacy)
+        end
+        facts
+      end
+    end
+  end
+end
diff --git a/spec/facter/facts/aix/ssh_spec.rb b/spec/facter/facts/aix/ssh_spec.rb
index 28591eb63c..cb981febfd 100644
--- a/spec/facter/facts/aix/ssh_spec.rb
+++ b/spec/facter/facts/aix/ssh_spec.rb
@@ -5,12 +5,12 @@
     subject(:fact) { Facts::Aix::Ssh.new }
 
     let(:ssh) do
-      [Facter::Ssh.new(Facter::FingerPrint.new('sha1_value', 'sha256_value'), 'ecdsa', 'key_value', 'ecdsa')]
+      [Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'ecdsa', 'test', 'ecdsa')]
     end
     let(:value) do
       { 'ecdsa' => { 'fingerprints' =>
-                         { 'sha1' => 'sha1_value', 'sha256' => 'sha256_value' },
-                     'key' => 'key_value',
+                         { 'sha1' => 'test', 'sha256' => 'test' },
+                     'key' => 'test',
                      'type' => 'ecdsa' } }
     end
 
@@ -25,23 +25,16 @@
     end
 
     it 'returns a resolved fact' do
-      expect(fact.call_the_resolver)
-        .to be_an_instance_of(Array)
-        .and contain_exactly(
-          an_object_having_attributes(name: 'ssh', value: value),
-          an_object_having_attributes(name: 'sshecdsakey', value: 'key_value'),
-          an_object_having_attributes(name: 'sshfp_ecdsa', value: "sha1_value\nsha256_value")
-        )
+      expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+        have_attributes(name: 'ssh', value: value)
     end
 
     context 'when resolver returns empty array' do
       let(:ssh) { [] }
 
       it 'returns nil fact' do
-        expect(fact.call_the_resolver).to be_an_instance_of(Array)
-          .and contain_exactly(
-            an_object_having_attributes(name: 'ssh', value: nil)
-          )
+        expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+          have_attributes(name: 'ssh', value: nil)
       end
     end
   end
diff --git a/spec/facter/facts/aix/sshalgorithmkey_spec.rb b/spec/facter/facts/aix/sshalgorithmkey_spec.rb
new file mode 100644
index 0000000000..281c7a347d
--- /dev/null
+++ b/spec/facter/facts/aix/sshalgorithmkey_spec.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+describe Facts::Aix::Sshalgorithmkey do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Aix::Sshalgorithmkey.new }
+
+    let(:ssh) do
+      [Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'ecdsa', 'test', 'ecdsa'),
+       Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'rsa', 'test', 'rsa')]
+    end
+    let(:legacy_fact1) { { name: 'ecdsa', value: 'test' } }
+    let(:legacy_fact2) { { name: 'rsa', value: 'test' } }
+
+    before do
+      allow(Facter::Resolvers::SshResolver).to \
+        receive(:resolve).with(:ssh).and_return(ssh)
+    end
+
+    it 'calls Facter::Resolvers::SshResolver' do
+      fact.call_the_resolver
+      expect(Facter::Resolvers::SshResolver).to have_received(:resolve).with(:ssh)
+    end
+
+    it 'returns a list of resolved facts' do
+      expect(fact.call_the_resolver).to be_an_instance_of(Array).and \
+        contain_exactly(an_object_having_attributes(name: "ssh#{legacy_fact1[:name]}key", value: legacy_fact1[:value]),
+                        an_object_having_attributes(name: "ssh#{legacy_fact2[:name]}key", value: legacy_fact2[:value]))
+    end
+  end
+end
diff --git a/spec/facter/facts/aix/sshfp_algorithm_spec.rb b/spec/facter/facts/aix/sshfp_algorithm_spec.rb
new file mode 100644
index 0000000000..f282ca8f6f
--- /dev/null
+++ b/spec/facter/facts/aix/sshfp_algorithm_spec.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+describe Facts::Aix::SshfpAlgorithm do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Aix::SshfpAlgorithm.new }
+
+    let(:ssh) do
+      [Facter::Ssh.new(Facter::FingerPrint.new('sha11', 'sha2561'), 'ecdsa', 'test', 'ecdsa'),
+       Facter::Ssh.new(Facter::FingerPrint.new('sha12', 'sha2562'), 'rsa', 'test', 'rsa')]
+    end
+    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11 \n sha2561" } }
+    let(:legacy_fact2) { { name: 'rsa', value: "sha12 \n sha2562" } }
+
+    before do
+      allow(Facter::Resolvers::SshResolver).to \
+        receive(:resolve).with(:ssh).and_return(ssh)
+    end
+
+    it 'calls Facter::Resolvers::SshResolver' do
+      fact.call_the_resolver
+      expect(Facter::Resolvers::SshResolver).to have_received(:resolve).with(:ssh)
+    end
+
+    it 'returns a list of resolved facts' do
+      expect(fact.call_the_resolver).to be_an_instance_of(Array).and \
+        contain_exactly(an_object_having_attributes(name: "sshfp_#{legacy_fact1[:name]}", value: legacy_fact1[:value]),
+                        an_object_having_attributes(name: "sshfp_#{legacy_fact2[:name]}", value: legacy_fact2[:value]))
+    end
+  end
+end
diff --git a/spec/facter/facts/freebsd/ssh_spec.rb b/spec/facter/facts/freebsd/ssh_spec.rb
index 7c86b48c12..91e3c40a4b 100644
--- a/spec/facter/facts/freebsd/ssh_spec.rb
+++ b/spec/facter/facts/freebsd/ssh_spec.rb
@@ -5,12 +5,12 @@
     subject(:fact) { Facts::Freebsd::Ssh.new }
 
     let(:ssh) do
-      [Facter::Ssh.new(Facter::FingerPrint.new('sha1_value', 'sha256_value'), 'ecdsa', 'key_value', 'ecdsa')]
+      [Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'ecdsa', 'test', 'ecdsa')]
     end
     let(:value) do
       { 'ecdsa' => { 'fingerprints' =>
-                       { 'sha1' => 'sha1_value', 'sha256' => 'sha256_value' },
-                     'key' => 'key_value',
+                         { 'sha1' => 'test', 'sha256' => 'test' },
+                     'key' => 'test',
                      'type' => 'ecdsa' } }
     end
 
@@ -25,13 +25,8 @@
     end
 
     it 'returns a resolved fact' do
-      expect(fact.call_the_resolver)
-        .to be_an_instance_of(Array)
-        .and contain_exactly(
-          an_object_having_attributes(name: 'ssh', value: value),
-          an_object_having_attributes(name: 'sshecdsakey', value: 'key_value'),
-          an_object_having_attributes(name: 'sshfp_ecdsa', value: "sha1_value\nsha256_value")
-        )
+      expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+        have_attributes(name: 'ssh', value: value)
     end
   end
 end
diff --git a/spec/facter/facts/freebsd/sshalgorithmkey_spec.rb b/spec/facter/facts/freebsd/sshalgorithmkey_spec.rb
new file mode 100644
index 0000000000..5411c88256
--- /dev/null
+++ b/spec/facter/facts/freebsd/sshalgorithmkey_spec.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+describe Facts::Freebsd::Sshalgorithmkey do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Freebsd::Sshalgorithmkey.new }
+
+    let(:ssh) do
+      [Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'ecdsa', 'test', 'ecdsa'),
+       Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'rsa', 'test', 'rsa')]
+    end
+    let(:legacy_fact1) { { name: 'ecdsa', value: 'test' } }
+    let(:legacy_fact2) { { name: 'rsa', value: 'test' } }
+
+    before do
+      allow(Facter::Resolvers::SshResolver).to \
+        receive(:resolve).with(:ssh).and_return(ssh)
+    end
+
+    it 'calls Facter::Resolvers::SshResolver' do
+      fact.call_the_resolver
+      expect(Facter::Resolvers::SshResolver).to have_received(:resolve).with(:ssh)
+    end
+
+    it 'returns a resolved fact' do
+      expect(fact.call_the_resolver).to be_an_instance_of(Array).and \
+        contain_exactly(an_object_having_attributes(name: "ssh#{legacy_fact1[:name]}key", value: legacy_fact1[:value]),
+                        an_object_having_attributes(name: "ssh#{legacy_fact2[:name]}key", value: legacy_fact2[:value]))
+    end
+  end
+end
diff --git a/spec/facter/facts/freebsd/sshfp_algorithm_spec.rb b/spec/facter/facts/freebsd/sshfp_algorithm_spec.rb
new file mode 100644
index 0000000000..ebe06b5f89
--- /dev/null
+++ b/spec/facter/facts/freebsd/sshfp_algorithm_spec.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+describe Facts::Freebsd::SshfpAlgorithm do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Freebsd::SshfpAlgorithm.new }
+
+    let(:ssh) do
+      [Facter::Ssh.new(Facter::FingerPrint.new('sha11', 'sha2561'), 'ecdsa', 'test', 'ecdsa'),
+       Facter::Ssh.new(Facter::FingerPrint.new('sha12', 'sha2562'), 'rsa', 'test', 'rsa')]
+    end
+    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11 \n sha2561" } }
+    let(:legacy_fact2) { { name: 'rsa', value: "sha12 \n sha2562" } }
+
+    before do
+      allow(Facter::Resolvers::SshResolver).to \
+        receive(:resolve).with(:ssh).and_return(ssh)
+    end
+
+    it 'calls Facter::Resolvers::SshResolver' do
+      fact.call_the_resolver
+      expect(Facter::Resolvers::SshResolver).to have_received(:resolve).with(:ssh)
+    end
+
+    it 'returns a resolved fact' do
+      expect(fact.call_the_resolver).to be_an_instance_of(Array).and \
+        contain_exactly(an_object_having_attributes(name: "sshfp_#{legacy_fact1[:name]}", value: legacy_fact1[:value]),
+                        an_object_having_attributes(name: "sshfp_#{legacy_fact2[:name]}", value: legacy_fact2[:value]))
+    end
+  end
+end
diff --git a/spec/facter/facts/linux/ssh_spec.rb b/spec/facter/facts/linux/ssh_spec.rb
index 0d5202267c..3730d98bfe 100644
--- a/spec/facter/facts/linux/ssh_spec.rb
+++ b/spec/facter/facts/linux/ssh_spec.rb
@@ -5,12 +5,12 @@
     subject(:fact) { Facts::Linux::Ssh.new }
 
     let(:ssh) do
-      [Facter::Ssh.new(Facter::FingerPrint.new('sha1_value', 'sha256_value'), 'ecdsa', 'key_value', 'ecdsa')]
+      [Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'ecdsa', 'test', 'ecdsa')]
     end
     let(:value) do
       { 'ecdsa' => { 'fingerprints' =>
-                       { 'sha1' => 'sha1_value', 'sha256' => 'sha256_value' },
-                     'key' => 'key_value',
+                         { 'sha1' => 'test', 'sha256' => 'test' },
+                     'key' => 'test',
                      'type' => 'ecdsa' } }
     end
 
@@ -24,24 +24,17 @@
       expect(Facter::Resolvers::SshResolver).to have_received(:resolve).with(:ssh)
     end
 
-    it 'returns a resolved fact' do
-      expect(fact.call_the_resolver)
-        .to be_an_instance_of(Array)
-        .and contain_exactly(
-          an_object_having_attributes(name: 'ssh', value: value),
-          an_object_having_attributes(name: 'sshecdsakey', value: 'key_value'),
-          an_object_having_attributes(name: 'sshfp_ecdsa', value: "sha1_value\nsha256_value")
-        )
+    it 'returns ssh fact' do
+      expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+        have_attributes(name: 'ssh', value: value)
     end
 
     context 'when resolver returns empty array' do
       let(:ssh) { [] }
 
       it 'returns nil fact' do
-        expect(fact.call_the_resolver).to be_an_instance_of(Array)
-          .and contain_exactly(
-            an_object_having_attributes(name: 'ssh', value: nil)
-          )
+        expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+          have_attributes(name: 'ssh', value: nil)
       end
     end
   end
diff --git a/spec/facter/facts/linux/sshalgorithmkey_spec.rb b/spec/facter/facts/linux/sshalgorithmkey_spec.rb
index 500a35c5be..dd2a781536 100644
--- a/spec/facter/facts/linux/sshalgorithmkey_spec.rb
+++ b/spec/facter/facts/linux/sshalgorithmkey_spec.rb
@@ -21,7 +21,7 @@
       expect(Facter::Resolvers::SshResolver).to have_received(:resolve).with(:ssh)
     end
 
-    it 'returns a resolved fact' do
+    it 'returns a list of resolved facts' do
       expect(fact.call_the_resolver).to be_an_instance_of(Array).and \
         contain_exactly(an_object_having_attributes(name: "ssh#{legacy_fact1[:name]}key", value: legacy_fact1[:value]),
                         an_object_having_attributes(name: "ssh#{legacy_fact2[:name]}key", value: legacy_fact2[:value]))
diff --git a/spec/facter/facts/linux/sshfp_algorithm_spec.rb b/spec/facter/facts/linux/sshfp_algorithm_spec.rb
index ed35e6b7b7..5c950cc34a 100644
--- a/spec/facter/facts/linux/sshfp_algorithm_spec.rb
+++ b/spec/facter/facts/linux/sshfp_algorithm_spec.rb
@@ -21,7 +21,7 @@
       expect(Facter::Resolvers::SshResolver).to have_received(:resolve).with(:ssh)
     end
 
-    it 'returns a resolved fact' do
+    it 'returns a list of resolved facts' do
       expect(fact.call_the_resolver).to be_an_instance_of(Array).and \
         contain_exactly(an_object_having_attributes(name: "sshfp_#{legacy_fact1[:name]}", value: legacy_fact1[:value]),
                         an_object_having_attributes(name: "sshfp_#{legacy_fact2[:name]}", value: legacy_fact2[:value]))
diff --git a/spec/facter/facts/macosx/ssh_spec.rb b/spec/facter/facts/macosx/ssh_spec.rb
index cf93cc1134..9ef195cf4b 100644
--- a/spec/facter/facts/macosx/ssh_spec.rb
+++ b/spec/facter/facts/macosx/ssh_spec.rb
@@ -5,12 +5,12 @@
     subject(:fact) { Facts::Macosx::Ssh.new }
 
     let(:ssh) do
-      [Facter::Ssh.new(Facter::FingerPrint.new('sha1_value', 'sha256_value'), 'ecdsa', 'key_value', 'ecdsa')]
+      [Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'ecdsa', 'test', 'ecdsa')]
     end
     let(:value) do
       { 'ecdsa' => { 'fingerprints' =>
-                       { 'sha1' => 'sha1_value', 'sha256' => 'sha256_value' },
-                     'key' => 'key_value',
+                         { 'sha1' => 'test', 'sha256' => 'test' },
+                     'key' => 'test',
                      'type' => 'ecdsa' } }
     end
 
@@ -25,23 +25,16 @@
     end
 
     it 'returns a resolved fact' do
-      expect(fact.call_the_resolver)
-        .to be_an_instance_of(Array)
-        .and contain_exactly(
-          an_object_having_attributes(name: 'ssh', value: value),
-          an_object_having_attributes(name: 'sshecdsakey', value: 'key_value'),
-          an_object_having_attributes(name: 'sshfp_ecdsa', value: "sha1_value\nsha256_value")
-        )
+      expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+        have_attributes(name: 'ssh', value: value)
     end
 
     context 'when resolver returns empty list' do
       let(:ssh) { [] }
 
-      it 'returns nil fact' do
-        expect(fact.call_the_resolver).to be_an_instance_of(Array)
-          .and contain_exactly(
-            an_object_having_attributes(name: 'ssh', value: nil)
-          )
+      it 'returns a nil fact' do
+        expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+          have_attributes(name: 'ssh', value: nil)
       end
     end
   end
diff --git a/spec/facter/facts/macosx/sshalgorithmkey_spec.rb b/spec/facter/facts/macosx/sshalgorithmkey_spec.rb
index f8555f740c..f1b31fc664 100644
--- a/spec/facter/facts/macosx/sshalgorithmkey_spec.rb
+++ b/spec/facter/facts/macosx/sshalgorithmkey_spec.rb
@@ -21,7 +21,7 @@
       expect(Facter::Resolvers::SshResolver).to have_received(:resolve).with(:ssh)
     end
 
-    it 'returns a resolved fact' do
+    it 'returns a list of resolved facts' do
       expect(fact.call_the_resolver).to be_an_instance_of(Array).and \
         contain_exactly(an_object_having_attributes(name: "ssh#{legacy_fact1[:name]}key", value: legacy_fact1[:value]),
                         an_object_having_attributes(name: "ssh#{legacy_fact2[:name]}key", value: legacy_fact2[:value]))
diff --git a/spec/facter/facts/macosx/sshfp_algorithm_spec.rb b/spec/facter/facts/macosx/sshfp_algorithm_spec.rb
index b1b0490bc0..70cfbe5df0 100644
--- a/spec/facter/facts/macosx/sshfp_algorithm_spec.rb
+++ b/spec/facter/facts/macosx/sshfp_algorithm_spec.rb
@@ -21,7 +21,7 @@
       expect(Facter::Resolvers::SshResolver).to have_received(:resolve).with(:ssh)
     end
 
-    it 'returns a resolved fact' do
+    it 'returns a list of resolved facts' do
       expect(fact.call_the_resolver).to be_an_instance_of(Array).and \
         contain_exactly(an_object_having_attributes(name: "sshfp_#{legacy_fact1[:name]}", value: legacy_fact1[:value]),
                         an_object_having_attributes(name: "sshfp_#{legacy_fact2[:name]}", value: legacy_fact2[:value]))
diff --git a/spec/facter/facts/solaris/ssh_spec.rb b/spec/facter/facts/solaris/ssh_spec.rb
index 359e5b79de..5cb1772f42 100644
--- a/spec/facter/facts/solaris/ssh_spec.rb
+++ b/spec/facter/facts/solaris/ssh_spec.rb
@@ -5,12 +5,12 @@
     subject(:fact) { Facts::Solaris::Ssh.new }
 
     let(:ssh) do
-      [Facter::Ssh.new(Facter::FingerPrint.new('sha1_value', 'sha256_value'), 'ecdsa', 'key_value', 'ecdsa')]
+      [Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'ecdsa', 'test', 'ecdsa')]
     end
     let(:value) do
       { 'ecdsa' => { 'fingerprints' =>
-                       { 'sha1' => 'sha1_value', 'sha256' => 'sha256_value' },
-                     'key' => 'key_value',
+                         { 'sha1' => 'test', 'sha256' => 'test' },
+                     'key' => 'test',
                      'type' => 'ecdsa' } }
     end
 
@@ -25,23 +25,16 @@
     end
 
     it 'returns a resolved fact' do
-      expect(fact.call_the_resolver)
-        .to be_an_instance_of(Array)
-        .and contain_exactly(
-          an_object_having_attributes(name: 'ssh', value: value),
-          an_object_having_attributes(name: 'sshecdsakey', value: 'key_value'),
-          an_object_having_attributes(name: 'sshfp_ecdsa', value: "sha1_value\nsha256_value")
-        )
+      expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+        have_attributes(name: 'ssh', value: value)
     end
 
     context 'when resolver returns empty array' do
       let(:ssh) { [] }
 
       it 'returns nil fact' do
-        expect(fact.call_the_resolver).to be_an_instance_of(Array)
-          .and contain_exactly(
-            an_object_having_attributes(name: 'ssh', value: nil)
-          )
+        expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+          have_attributes(name: 'ssh', value: nil)
       end
     end
   end
diff --git a/spec/facter/facts/solaris/sshalgorithmkey_spec.rb b/spec/facter/facts/solaris/sshalgorithmkey_spec.rb
new file mode 100644
index 0000000000..bc81129471
--- /dev/null
+++ b/spec/facter/facts/solaris/sshalgorithmkey_spec.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+describe Facts::Solaris::Sshalgorithmkey do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Solaris::Sshalgorithmkey.new }
+
+    let(:ssh) do
+      [Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'ecdsa', 'test', 'ecdsa'),
+       Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'rsa', 'test', 'rsa')]
+    end
+    let(:legacy_fact1) { { name: 'ecdsa', value: 'test' } }
+    let(:legacy_fact2) { { name: 'rsa', value: 'test' } }
+
+    before do
+      allow(Facter::Resolvers::SshResolver).to \
+        receive(:resolve).with(:ssh).and_return(ssh)
+    end
+
+    it 'calls Facter::Resolvers::SshResolver' do
+      fact.call_the_resolver
+      expect(Facter::Resolvers::SshResolver).to have_received(:resolve).with(:ssh)
+    end
+
+    it 'returns a list of resolved facts' do
+      expect(fact.call_the_resolver).to be_an_instance_of(Array).and \
+        contain_exactly(an_object_having_attributes(name: "ssh#{legacy_fact1[:name]}key", value: legacy_fact1[:value]),
+                        an_object_having_attributes(name: "ssh#{legacy_fact2[:name]}key", value: legacy_fact2[:value]))
+    end
+  end
+end
diff --git a/spec/facter/facts/solaris/sshfp_algorithm_spec.rb b/spec/facter/facts/solaris/sshfp_algorithm_spec.rb
new file mode 100644
index 0000000000..8db3ab38ef
--- /dev/null
+++ b/spec/facter/facts/solaris/sshfp_algorithm_spec.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+describe Facts::Solaris::SshfpAlgorithm do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Solaris::SshfpAlgorithm.new }
+
+    let(:ssh) do
+      [Facter::Ssh.new(Facter::FingerPrint.new('sha11', 'sha2561'), 'ecdsa', 'test', 'ecdsa'),
+       Facter::Ssh.new(Facter::FingerPrint.new('sha12', 'sha2562'), 'rsa', 'test', 'rsa')]
+    end
+    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11 \n sha2561" } }
+    let(:legacy_fact2) { { name: 'rsa', value: "sha12 \n sha2562" } }
+
+    before do
+      allow(Facter::Resolvers::SshResolver).to \
+        receive(:resolve).with(:ssh).and_return(ssh)
+    end
+
+    it 'calls Facter::Resolvers::SshResolver' do
+      fact.call_the_resolver
+      expect(Facter::Resolvers::SshResolver).to have_received(:resolve).with(:ssh)
+    end
+
+    it 'returns a list of resolved facts' do
+      expect(fact.call_the_resolver).to be_an_instance_of(Array).and \
+        contain_exactly(an_object_having_attributes(name: "sshfp_#{legacy_fact1[:name]}", value: legacy_fact1[:value]),
+                        an_object_having_attributes(name: "sshfp_#{legacy_fact2[:name]}", value: legacy_fact2[:value]))
+    end
+  end
+end
diff --git a/spec/facter/facts/windows/ssh_spec.rb b/spec/facter/facts/windows/ssh_spec.rb
index 454afabe0e..66e8b0cbb8 100644
--- a/spec/facter/facts/windows/ssh_spec.rb
+++ b/spec/facter/facts/windows/ssh_spec.rb
@@ -6,12 +6,12 @@
 
     context 'when user is privileged' do
       let(:ssh) do
-        [Facter::Ssh.new(Facter::FingerPrint.new('sha1_value', 'sha256_value'), 'ecdsa', 'key_value', 'ecdsa')]
+        [Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'ecdsa', 'test', 'ecdsa')]
       end
       let(:value) do
         { 'ecdsa' => { 'fingerprints' =>
-                         { 'sha1' => 'sha1_value', 'sha256' => 'sha256_value' },
-                       'key' => 'key_value',
+                         { 'sha1' => 'test', 'sha256' => 'test' },
+                       'key' => 'test',
                        'type' => 'ecdsa' } }
       end
 
@@ -31,13 +31,8 @@
       end
 
       it 'returns ssh fact' do
-        expect(fact.call_the_resolver)
-          .to be_an_instance_of(Array)
-          .and contain_exactly(
-            an_object_having_attributes(name: 'ssh', value: value),
-            an_object_having_attributes(name: 'sshecdsakey', value: 'key_value'),
-            an_object_having_attributes(name: 'sshfp_ecdsa', value: "sha1_value\nsha256_value")
-          )
+        expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+          have_attributes(name: 'ssh', value: value)
       end
     end
 
@@ -60,10 +55,8 @@
       end
 
       it 'returns ssh fact' do
-        expect(fact.call_the_resolver).to be_an_instance_of(Array)
-          .and contain_exactly(
-            an_object_having_attributes(name: 'ssh', value: value)
-          )
+        expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+          have_attributes(name: 'ssh', value: value)
       end
     end
 
@@ -86,10 +79,8 @@
       end
 
       it 'returns ssh fact' do
-        expect(fact.call_the_resolver).to be_an_instance_of(Array)
-          .and contain_exactly(
-            an_object_having_attributes(name: 'ssh', value: nil)
-          )
+        expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+          have_attributes(name: 'ssh', value: value)
       end
     end
   end
diff --git a/spec/facter/facts/windows/sshalgorithmkey_spec.rb b/spec/facter/facts/windows/sshalgorithmkey_spec.rb
new file mode 100644
index 0000000000..d686c426de
--- /dev/null
+++ b/spec/facter/facts/windows/sshalgorithmkey_spec.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+describe Facts::Windows::Sshalgorithmkey do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Windows::Sshalgorithmkey.new }
+
+    context 'when user is privileged' do
+      let(:ssh) do
+        [Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'ecdsa', 'test', 'ecdsa'),
+         Facter::Ssh.new(Facter::FingerPrint.new('test', 'test'), 'rsa', 'test', 'rsa')]
+      end
+      let(:legacy_fact1) { { name: 'ecdsa', value: 'test' } }
+      let(:legacy_fact2) { { name: 'rsa', value: 'test' } }
+
+      before do
+        allow(Facter::Resolvers::Identity).to receive(:resolve).with(:privileged).and_return(true)
+        allow(Facter::Resolvers::Windows::Ssh).to receive(:resolve).with(:ssh).and_return(ssh)
+      end
+
+      it 'calls Facter::Resolvers::Windows::Identity' do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Identity).to have_received(:resolve).with(:privileged)
+      end
+
+      it 'calls Facter::Resolvers::Windows::Ssh' do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Windows::Ssh).to have_received(:resolve).with(:ssh)
+      end
+
+      it 'returns a list of resolved facts' do
+        expect(fact.call_the_resolver).to be_an_instance_of(Array).and \
+          contain_exactly(
+            an_object_having_attributes(name: "ssh#{legacy_fact1[:name]}key", value: legacy_fact1[:value]),
+            an_object_having_attributes(name: "ssh#{legacy_fact2[:name]}key", value: legacy_fact2[:value])
+          )
+      end
+    end
+
+    context 'when user is privileged but no ssh key found' do
+      let(:value) { nil }
+
+      before do
+        allow(Facter::Resolvers::Identity).to receive(:resolve).with(:privileged).and_return(true)
+        allow(Facter::Resolvers::Windows::Ssh).to receive(:resolve).with(:ssh).and_return(nil)
+      end
+
+      it 'calls Facter::Resolvers::Windows::Ssh' do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Windows::Ssh).to have_received(:resolve).with(:ssh)
+      end
+
+      it 'calls Facter::Resolvers::Windows::Identity' do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Identity).to have_received(:resolve).with(:privileged)
+      end
+
+      it 'returns no facts' do
+        expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly
+      end
+    end
+
+    context 'when user is not privileged' do
+      let(:value) { nil }
+
+      before do
+        allow(Facter::Resolvers::Identity).to receive(:resolve).with(:privileged).and_return(false)
+        allow(Facter::Resolvers::Windows::Ssh).to receive(:resolve).with(:ssh).and_return(value)
+      end
+
+      it 'calls Facter::Resolvers::Windows::Identity' do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Identity).to have_received(:resolve).with(:privileged)
+      end
+
+      it "doesn't call Facter::Resolvers::Windows::Ssh" do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Windows::Ssh).not_to have_received(:resolve).with(:ssh)
+      end
+
+      it 'returns no facts' do
+        expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly
+      end
+    end
+  end
+end
diff --git a/spec/facter/facts/windows/sshfp_algorithm_spec.rb b/spec/facter/facts/windows/sshfp_algorithm_spec.rb
new file mode 100644
index 0000000000..7908a11e3e
--- /dev/null
+++ b/spec/facter/facts/windows/sshfp_algorithm_spec.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+describe Facts::Windows::SshfpAlgorithm do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Windows::SshfpAlgorithm.new }
+
+    context 'when user is privileged' do
+      let(:ssh) do
+        [Facter::Ssh.new(Facter::FingerPrint.new('sha11', 'sha2561'), 'ecdsa', 'test', 'ecdsa'),
+         Facter::Ssh.new(Facter::FingerPrint.new('sha12', 'sha2562'), 'rsa', 'test', 'rsa')]
+      end
+      let(:legacy_fact1) { { name: 'ecdsa', value: "sha11 \n sha2561" } }
+      let(:legacy_fact2) { { name: 'rsa', value: "sha12 \n sha2562" } }
+
+      before do
+        allow(Facter::Resolvers::Identity).to receive(:resolve).with(:privileged).and_return(true)
+        allow(Facter::Resolvers::Windows::Ssh).to receive(:resolve).with(:ssh).and_return(ssh)
+      end
+
+      it 'calls Facter::Resolvers::Windows::Identity' do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Identity).to have_received(:resolve).with(:privileged)
+      end
+
+      it 'calls Facter::Resolvers::Windows::Ssh' do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Windows::Ssh).to have_received(:resolve).with(:ssh)
+      end
+
+      it 'returns a list of resolved facts' do
+        expect(fact.call_the_resolver).to be_an_instance_of(Array).and \
+          contain_exactly(
+            an_object_having_attributes(name: "sshfp_#{legacy_fact1[:name]}", value: legacy_fact1[:value]),
+            an_object_having_attributes(name: "sshfp_#{legacy_fact2[:name]}", value: legacy_fact2[:value])
+          )
+      end
+    end
+
+    context 'when user is privileged but no ssh key found' do
+      let(:value) { nil }
+
+      before do
+        allow(Facter::Resolvers::Identity).to receive(:resolve).with(:privileged).and_return(true)
+        allow(Facter::Resolvers::Windows::Ssh).to receive(:resolve).with(:ssh).and_return(nil)
+      end
+
+      it 'calls Facter::Resolvers::Windows::Ssh' do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Windows::Ssh).to have_received(:resolve).with(:ssh)
+      end
+
+      it 'calls Facter::Resolvers::Windows::Identity' do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Identity).to have_received(:resolve).with(:privileged)
+      end
+
+      it 'returns no facts' do
+        expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly
+      end
+    end
+
+    context 'when user is not privileged' do
+      let(:value) { nil }
+
+      before do
+        allow(Facter::Resolvers::Identity).to receive(:resolve).with(:privileged).and_return(false)
+        allow(Facter::Resolvers::Windows::Ssh).to receive(:resolve).with(:ssh).and_return(value)
+      end
+
+      it 'calls Facter::Resolvers::Windows::Identity' do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Identity).to have_received(:resolve).with(:privileged)
+      end
+
+      it "doesn't call Facter::Resolvers::Windows::Ssh" do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Windows::Ssh).not_to have_received(:resolve).with(:ssh)
+      end
+
+      it 'returns no facts' do
+        expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly
+      end
+    end
+  end
+end