class SSHKey

# File lib/sshkey.rb, line 26
def generate(options = {})
  type   = options[:type] || "rsa"

  # JRuby modulus size must range from 512 to 1024
  default_bits = type == "rsa" ? 2048 : 1024

  bits   = options[:bits] || default_bits
  cipher = OpenSSL::Cipher::Cipher.new("AES-128-CBC") if options[:passphrase]

  case type.downcase
  when "rsa" then new(OpenSSL::PKey::RSA.generate(bits).to_pem(cipher, options[:passphrase]), options)
  when "dsa" then new(OpenSSL::PKey::DSA.generate(bits).to_pem(cipher, options[:passphrase]), options)
  else
    raise "Unknown key type: #{type}"
  end
end

# File lib/sshkey.rb, line 81
def md5_fingerprint(key)
  if key.match(/PRIVATE/)
    new(key).md5_fingerprint
  else
    Digest::MD5.hexdigest(decoded_key(key)).gsub(fingerprint_regex, '\1:\2')
  end
end

# File lib/sshkey.rb, line 127
def initialize(private_key, options = {})
  @passphrase = options[:passphrase]
  @comment    = options[:comment] || ""
  begin
    @key_object = OpenSSL::PKey::RSA.new(private_key, passphrase)
    @type = "rsa"
  rescue
    @key_object = OpenSSL::PKey::DSA.new(private_key, passphrase)
    @type = "dsa"
  end
end

# File lib/sshkey.rb, line 91
def sha1_fingerprint(key)
  if key.match(/PRIVATE/)
    new(key).sha1_fingerprint
  else
    Digest::SHA1.hexdigest(decoded_key(key)).gsub(fingerprint_regex, '\1:\2')
  end
end

# File lib/sshkey.rb, line 50
def valid_ssh_public_key?(ssh_public_key)
  ssh_type, encoded_key = ssh_public_key.split(" ")
  type = SSH_TYPES.invert[ssh_type]
  prefix = [0,0,0,7].pack("C*")
  decoded = Base64.decode64(encoded_key)

  # Base64 decoding is too permissive, so we should validate if encoding is correct
  return false unless Base64.encode64(decoded).gsub("\n", "") == encoded_key
  return false unless decoded.sub!(/^#{prefix}#{ssh_type}/, "")

  unpacked = decoded.unpack("C*")
  data = []
  index = 0
  until unpacked[index].nil?
    datum_size = from_byte_array unpacked[index..index+4-1], 4
    index = index + 4
    datum = from_byte_array unpacked[index..index+datum_size-1], datum_size
    data << datum
    index = index + datum_size
  end

  SSH_CONVERSION[type].size == data.size
rescue
  false
end

# File lib/sshkey.rb, line 110
def decoded_key(key)
  Base64.decode64(key.chomp.gsub(/ssh-[dr]s[as] /, ''))
end

# File lib/sshkey.rb, line 114
def fingerprint_regex
  /(.{2})(?=.)/
end

# File lib/sshkey.rb, line 101
def from_byte_array(byte_array, expected_size = nil)
  num = 0
  raise "Byte array too short" if !expected_size.nil? && expected_size != byte_array.size
  byte_array.reverse.each_with_index do |item, index|
    num += item * 256**(index)
  end
  num
end

# File lib/sshkey.rb, line 151
def encrypted_private_key
  return private_key unless passphrase
  key_object.to_pem(OpenSSL::Cipher::Cipher.new("AES-128-CBC"), passphrase)
end

# File lib/sshkey.rb, line 173
def md5_fingerprint
  Digest::MD5.hexdigest(ssh_public_key_conversion).gsub(/(.{2})(?=.)/, '\1:\2')
end

# File lib/sshkey.rb, line 142
def private_key
  key_object.to_pem
end

# File lib/sshkey.rb, line 159
def public_key
  key_object.public_key.to_pem
end

# File lib/sshkey.rb, line 179
def sha1_fingerprint
  Digest::SHA1.hexdigest(ssh_public_key_conversion).gsub(/(.{2})(?=.)/, '\1:\2')
end

# File lib/sshkey.rb, line 166
def ssh_public_key
  [SSH_TYPES[type], Base64.encode64(ssh_public_key_conversion).gsub("\n", ""), comment].join(" ").strip
end

# File lib/sshkey.rb, line 207
def encode_unsigned_int_32(value)
  out = []
  out[0] = value >> 24 & 0xff
  out[1] = value >> 16 & 0xff
  out[2] = value >> 8 & 0xff
  out[3] = value & 0xff
  return out
end

# File lib/sshkey.rb, line 194
def ssh_public_key_conversion
  out = [0,0,0,7].pack("C*")
  out += SSH_TYPES[type]

  SSH_CONVERSION[type].each do |method|
    byte_array = to_byte_array(key_object.public_key.send(method).to_i)
    out += encode_unsigned_int_32(byte_array.length).pack("c*")
    out += byte_array.pack("C*")
  end

  return out
end

# File lib/sshkey.rb, line 216
def to_byte_array(num)
  result = []
  begin
    result << (num & 0xff)
    num >>= 8
  end until (num == 0 || num == -1) && (result.last[7] == num[7])
  result.reverse
end