ssh_data 1.1.0

data/lib/ssh_data/public_key.rb

@@ -0,0 +1,78 @@
+module SSHData
+  module PublicKey
+    # Public key algorithm identifiers
+    ALGO_RSA      = "ssh-rsa"
+    ALGO_DSA      = "ssh-dss"
+    ALGO_ECDSA256 = "ecdsa-sha2-nistp256"
+    ALGO_ECDSA384 = "ecdsa-sha2-nistp384"
+    ALGO_ECDSA521 = "ecdsa-sha2-nistp521"
+    ALGO_ED25519  = "ssh-ed25519"
+
+    # RSA SHA2 *signature* algorithms used with ALGO_RSA keys.
+    # https://tools.ietf.org/html/draft-rsa-dsa-sha2-256-02
+    ALGO_RSA_SHA2_256 = "rsa-sha2-256"
+    ALGO_RSA_SHA2_512 = "rsa-sha2-512"
+
+    ALGOS = [
+      ALGO_RSA, ALGO_DSA, ALGO_ECDSA256, ALGO_ECDSA384, ALGO_ECDSA521,
+      ALGO_ED25519
+    ]
+
+    # Parse an OpenSSH public key in authorized_keys format (see sshd(8) manual
+    # page).
+    #
+    # key - An OpenSSH formatted public key, including algo, base64 encoded key
+    #       and optional comment.
+    #
+    # Returns a PublicKey::Base subclass instance.
+    def self.parse_openssh(key)
+      algo, raw, _ = SSHData.key_parts(key)
+      parsed = parse_rfc4253(raw)
+
+      if parsed.algo != algo
+        raise DecodeError, "algo mismatch: #{parsed.algo.inspect}!=#{algo.inspect}"
+      end
+
+      parsed
+    end
+
+    # Deprecated
+    singleton_class.send(:alias_method, :parse, :parse_openssh)
+
+    # Parse an RFC 4253 binary SSH public key.
+    #
+    # key - A RFC 4253 binary public key String.
+    #
+    # Returns a PublicKey::Base subclass instance.
+    def self.parse_rfc4253(raw)
+      data, read = Encoding.decode_public_key(raw)
+
+      if read != raw.bytesize
+        raise DecodeError, "unexpected trailing data"
+      end
+
+      from_data(data)
+    end
+
+    def self.from_data(data)
+      case data[:algo]
+      when ALGO_RSA
+        RSA.new(**data)
+      when ALGO_DSA
+        DSA.new(**data)
+      when ALGO_ECDSA256, ALGO_ECDSA384, ALGO_ECDSA521
+        ECDSA.new(**data)
+      when ALGO_ED25519
+        ED25519.new(**data)
+      else
+        raise DecodeError, "unkown algo: #{data[:algo].inspect}"
+      end
+    end
+  end
+end
+
+require "ssh_data/public_key/base"
+require "ssh_data/public_key/rsa"
+require "ssh_data/public_key/dsa"
+require "ssh_data/public_key/ecdsa"
+require "ssh_data/public_key/ed25519"

data/lib/ssh_data/public_key/base.rb

@@ -0,0 +1,71 @@
+module SSHData
+  module PublicKey
+    class Base
+      attr_reader :algo
+
+      def initialize(**kwargs)
+        @algo = kwargs[:algo]
+      end
+
+      # Calculate the fingerprint of this public key.
+      #
+      # md5: - Bool of whether to generate an MD5 fingerprint instead of the
+      #        default SHA256.
+      #
+      # Returns a String fingerprint.
+      def fingerprint(md5: false)
+        if md5
+          # colon separated, hex encoded md5 digest
+          OpenSSL::Digest::MD5.digest(rfc4253).unpack("H2" * 16).join(":")
+        else
+          # base64 encoded sha256 digest with b64 padding stripped
+          Base64.strict_encode64(OpenSSL::Digest::SHA256.digest(rfc4253))[0...-1]
+        end
+      end
+
+      # Make an SSH signature.
+      #
+      # signed_data - The String message over which to calculated the signature.
+      #
+      # Returns a binary String signature.
+      def sign(signed_data)
+        raise "implement me"
+      end
+
+      # Verify an SSH signature.
+      #
+      # signed_data - The String message that the signature was calculated over.
+      # signature   - The binary String signature with SSH encoding.
+      #
+      # Returns boolean.
+      def verify(signed_data, signature)
+        raise "implement me"
+      end
+
+      # RFC4253 binary encoding of the public key.
+      #
+      # Returns a binary String.
+      def rfc4253
+        raise "implement me"
+      end
+
+      # OpenSSH public key in authorized_keys format (see sshd(8) manual page).
+      #
+      # comment - Optional String comment to append.
+      #
+      # Returns a String key.
+      def openssh(comment: nil)
+        [algo, Base64.strict_encode64(rfc4253), comment].compact.join(" ")
+      end
+
+      # Is this public key equal to another public key?
+      #
+      # other - Another SSHData::PublicKey::Base instance to compare with.
+      #
+      # Returns boolean.
+      def ==(other)
+        other.class == self.class
+      end
+    end
+  end
+end

data/lib/ssh_data/public_key/dsa.rb

@@ -0,0 +1,122 @@
+module SSHData
+  module PublicKey
+    class DSA < Base
+      attr_reader :p, :q, :g, :y, :openssl
+
+      # Convert an SSH encoded DSA signature to DER encoding for verification with
+      # OpenSSL.
+      #
+      # sig - A binary String signature from an SSH packet.
+      #
+      # Returns a binary String signature, as expected by OpenSSL.
+      def self.openssl_signature(sig)
+        if sig.bytesize != 40
+          raise DecodeError, "bad DSA signature size"
+        end
+
+        r = OpenSSL::BN.new(sig.byteslice(0, 20), 2)
+        s = OpenSSL::BN.new(sig.byteslice(20, 20), 2)
+
+        OpenSSL::ASN1::Sequence.new([
+          OpenSSL::ASN1::Integer.new(r),
+          OpenSSL::ASN1::Integer.new(s)
+        ]).to_der
+      end
+
+      # Convert an DER encoded DSA signature, as generated by OpenSSL to SSH
+      # encoding.
+      #
+      # sig - A binary String signature, as generated by OpenSSL.
+      #
+      # Returns a binary String signature, as found in an SSH packet.
+      def self.ssh_signature(sig)
+        a1 = OpenSSL::ASN1.decode(sig)
+        if a1.tag_class != :UNIVERSAL || a1.tag != OpenSSL::ASN1::SEQUENCE || a1.value.count != 2
+          raise DecodeError, "bad asn1 signature"
+        end
+
+        r, s = a1.value
+        if r.tag_class != :UNIVERSAL || r.tag != OpenSSL::ASN1::INTEGER || s.tag_class != :UNIVERSAL || s.tag != OpenSSL::ASN1::INTEGER
+          raise DecodeError, "bad asn1 signature"
+        end
+
+        # left pad big endian representations to 20 bytes and concatenate
+        [
+          "\x00" * (20 - r.value.num_bytes),
+          r.value.to_s(2),
+          "\x00" * (20 - s.value.num_bytes),
+          s.value.to_s(2)
+        ].join
+      end
+
+      def initialize(algo:, p:, q:, g:, y:)
+        unless algo == ALGO_DSA
+          raise DecodeError, "bad algorithm: #{algo.inspect}"
+        end
+
+        @p = p
+        @q = q
+        @g = g
+        @y = y
+
+        @openssl = OpenSSL::PKey::DSA.new(asn1.to_der)
+
+        super(algo: algo)
+      end
+
+      # Verify an SSH signature.
+      #
+      # signed_data - The String message that the signature was calculated over.
+      # signature   - The binarty String signature with SSH encoding.
+      #
+      # Returns boolean.
+      def verify(signed_data, signature)
+        sig_algo, ssh_sig, _ = Encoding.decode_signature(signature)
+        if sig_algo != ALGO_DSA
+          raise DecodeError, "bad signature algorithm: #{sig_algo.inspect}"
+        end
+
+        openssl_sig = self.class.openssl_signature(ssh_sig)
+        openssl.verify(OpenSSL::Digest::SHA1.new, openssl_sig, signed_data)
+      end
+
+      # RFC4253 binary encoding of the public key.
+      #
+      # Returns a binary String.
+      def rfc4253
+        Encoding.encode_fields(
+          [:string, algo],
+          [:mpint, p],
+          [:mpint, q],
+          [:mpint, g],
+          [:mpint, y],
+        )
+      end
+
+      # Is this public key equal to another public key?
+      #
+      # other - Another SSHData::PublicKey::Base instance to compare with.
+      #
+      # Returns boolean.
+      def ==(other)
+        super && other.p == p && other.q == q && other.g == g && other.y == y
+      end
+
+      private
+
+      def asn1
+        OpenSSL::ASN1::Sequence.new([
+          OpenSSL::ASN1::Sequence.new([
+            OpenSSL::ASN1::ObjectId.new("DSA"),
+            OpenSSL::ASN1::Sequence.new([
+              OpenSSL::ASN1::Integer.new(p),
+              OpenSSL::ASN1::Integer.new(q),
+              OpenSSL::ASN1::Integer.new(g),
+            ]),
+          ]),
+          OpenSSL::ASN1::BitString.new(OpenSSL::ASN1::Integer.new(y).to_der),
+        ])
+      end
+    end
+  end
+end

data/lib/ssh_data/public_key/ecdsa.rb

@@ -0,0 +1,151 @@
+module SSHData
+  module PublicKey
+    class ECDSA < Base
+      attr_reader :curve, :public_key_bytes, :openssl
+
+      NISTP256 = "nistp256"
+      NISTP384 = "nistp384"
+      NISTP521 = "nistp521"
+
+      OPENSSL_CURVE_NAME_FOR_CURVE = {
+        NISTP256 => "prime256v1",
+        NISTP384 => "secp384r1",
+        NISTP521 => "secp521r1",
+      }
+
+      CURVE_FOR_OPENSSL_CURVE_NAME = {
+        "prime256v1" => NISTP256,
+        "secp384r1"  => NISTP384,
+        "secp521r1"  => NISTP521,
+      }
+
+      DIGEST_FOR_CURVE = {
+        NISTP256 => OpenSSL::Digest::SHA256,
+        NISTP384 => OpenSSL::Digest::SHA384,
+        NISTP521 => OpenSSL::Digest::SHA512,
+      }
+
+      # Convert an SSH encoded ECDSA signature to DER encoding for verification with
+      # OpenSSL.
+      #
+      # sig - A binary String signature from an SSH packet.
+      #
+      # Returns a binary String signature, as expected by OpenSSL.
+      def self.openssl_signature(sig)
+        r, rlen = Encoding.decode_mpint(sig, 0)
+        s, slen = Encoding.decode_mpint(sig, rlen)
+
+        if rlen + slen != sig.bytesize
+          raise DecodeError, "unexpected trailing data"
+        end
+
+        OpenSSL::ASN1::Sequence.new([
+          OpenSSL::ASN1::Integer.new(r),
+          OpenSSL::ASN1::Integer.new(s)
+        ]).to_der
+      end
+
+      # Convert an DER encoded ECDSA signature, as generated by OpenSSL to SSH
+      # encoding.
+      #
+      # sig - A binary String signature, as generated by OpenSSL.
+      #
+      # Returns a binary String signature, as found in an SSH packet.
+      def self.ssh_signature(sig)
+        a1 = OpenSSL::ASN1.decode(sig)
+        if a1.tag_class != :UNIVERSAL || a1.tag != OpenSSL::ASN1::SEQUENCE || a1.value.count != 2
+          raise DecodeError, "bad asn1 signature"
+        end
+
+        r, s = a1.value
+        if r.tag_class != :UNIVERSAL || r.tag != OpenSSL::ASN1::INTEGER || s.tag_class != :UNIVERSAL || s.tag != OpenSSL::ASN1::INTEGER
+          raise DecodeError, "bad asn1 signature"
+        end
+
+        [Encoding.encode_mpint(r.value), Encoding.encode_mpint(s.value)].join
+      end
+
+      def initialize(algo:, curve:, public_key:)
+        unless [ALGO_ECDSA256, ALGO_ECDSA384, ALGO_ECDSA521].include?(algo)
+          raise DecodeError, "bad algorithm: #{algo.inspect}"
+        end
+
+        unless algo == "ecdsa-sha2-#{curve}"
+          raise DecodeError, "bad curve: #{curve.inspect}"
+        end
+
+        @curve = curve
+        @public_key_bytes = public_key
+
+        @openssl = begin
+          OpenSSL::PKey::EC.new(asn1.to_der)
+        rescue ArgumentError
+          raise DecodeError, "bad key data"
+        end
+
+        super(algo: algo)
+      end
+
+      # Verify an SSH signature.
+      #
+      # signed_data - The String message that the signature was calculated over.
+      # signature   - The binarty String signature with SSH encoding.
+      #
+      # Returns boolean.
+      def verify(signed_data, signature)
+        sig_algo, ssh_sig, _ = Encoding.decode_signature(signature)
+        if sig_algo != "ecdsa-sha2-#{curve}"
+          raise DecodeError, "bad signature algorithm: #{sig_algo.inspect}"
+        end
+
+        openssl_sig = self.class.openssl_signature(ssh_sig)
+        digest = DIGEST_FOR_CURVE[curve]
+
+        openssl.verify(digest.new, openssl_sig, signed_data)
+      end
+
+      # RFC4253 binary encoding of the public key.
+      #
+      # Returns a binary String.
+      def rfc4253
+        Encoding.encode_fields(
+          [:string, algo],
+          [:string, curve],
+          [:string, public_key_bytes],
+        )
+      end
+
+      # Is this public key equal to another public key?
+      #
+      # other - Another SSHData::PublicKey::Base instance to compare with.
+      #
+      # Returns boolean.
+      def ==(other)
+        super && other.curve == curve && other.public_key_bytes == public_key_bytes
+      end
+
+      # The digest algorithm to use with this key's curve.
+      #
+      # Returns an OpenSSL::Digest.
+      def digest
+        DIGEST_FOR_CURVE[curve]
+      end
+
+      private
+
+      def asn1
+        unless name = OPENSSL_CURVE_NAME_FOR_CURVE[curve]
+          raise DecodeError, "unknown curve: #{curve.inspect}"
+        end
+
+        OpenSSL::ASN1::Sequence.new([
+          OpenSSL::ASN1::Sequence.new([
+            OpenSSL::ASN1::ObjectId.new("id-ecPublicKey"),
+            OpenSSL::ASN1::ObjectId.new(name),
+          ]),
+          OpenSSL::ASN1::BitString.new(public_key_bytes),
+        ])
+      end
+    end
+  end
+end

data/lib/ssh_data/public_key/ed25519.rb

@@ -0,0 +1,74 @@
+module SSHData
+  module PublicKey
+    class ED25519 < Base
+      attr_reader :pk, :ed25519_key
+
+      # ed25519 isn't a hard requirement for using this Gem. We only do actual
+      # validation with the key if the ed25519 Gem has been loaded.
+      def self.enabled?
+        Object.const_defined?(:Ed25519)
+      end
+
+      # Assert that the ed25519 gem has been loaded.
+      #
+      # Returns nothing, raises AlgorithmError.
+      def self.ed25519_gem_required!
+        raise AlgorithmError, "the ed25519 gem is not loaded" unless enabled?
+      end
+
+      def initialize(algo:, pk:)
+        unless algo == ALGO_ED25519
+          raise DecodeError, "bad algorithm: #{algo.inspect}"
+        end
+
+        @pk = pk
+
+        if self.class.enabled?
+          @ed25519_key = Ed25519::VerifyKey.new(pk)
+        end
+
+        super(algo: algo)
+      end
+
+      # Verify an SSH signature.
+      #
+      # signed_data - The String message that the signature was calculated over.
+      # signature   - The binarty String signature with SSH encoding.
+      #
+      # Returns boolean.
+      def verify(signed_data, signature)
+        self.class.ed25519_gem_required!
+
+        sig_algo, raw_sig, _ = Encoding.decode_signature(signature)
+        if sig_algo != ALGO_ED25519
+          raise DecodeError, "bad signature algorithm: #{sig_algo.inspect}"
+        end
+
+        begin
+          ed25519_key.verify(raw_sig, signed_data)
+        rescue Ed25519::VerifyError
+          false
+        end
+      end
+
+      # RFC4253 binary encoding of the public key.
+      #
+      # Returns a binary String.
+      def rfc4253
+        Encoding.encode_fields(
+          [:string, algo],
+          [:string, pk],
+        )
+      end
+
+      # Is this public key equal to another public key?
+      #
+      # other - Another SSHData::PublicKey::Base instance to compare with.
+      #
+      # Returns boolean.
+      def ==(other)
+        super && other.pk == pk
+      end
+    end
+  end
+end