Merge branch 'dev' into bmk/inets/inet56_integration

7 files changed, 510 insertions, 60 deletions

diff --git a/lib/public_key/src/Makefile b/lib/public_key/src/Makefile
index b042b0c30a..5a24b02d2a 100644
--- a/lib/public_key/src/Makefile
+++ b/lib/public_key/src/Makefile
@@ -41,6 +41,7 @@ RELSYSDIR = $(RELEASE_PATH)/lib/public_key-$(VSN)
 MODULES = \
 	public_key \
 	pubkey_pem \
+	pubkey_ssh \
 	pubkey_cert \
         pubkey_cert_records 
 
diff --git a/lib/public_key/src/pubkey_cert.erl b/lib/public_key/src/pubkey_cert.erl
index fadb993ed9..5ab9642279 100644
--- a/lib/public_key/src/pubkey_cert.erl
+++ b/lib/public_key/src/pubkey_cert.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2008-2010. All Rights Reserved.
+%% Copyright Ericsson AB 2008-2011. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -38,7 +38,7 @@
 %%====================================================================
 
 %%--------------------------------------------------------------------
--spec verify_data(der_encoded()) -> {md5 | sha,  binary(), binary()}.
+-spec verify_data(DER::binary()) -> {md5 | sha,  binary(), binary()}.
 %%
 %% Description: Extracts data from DerCert needed to call public_key:verify/4.
 %%--------------------------------------------------------------------	 
@@ -146,7 +146,7 @@ validate_issuer(OtpCert, Issuer, UserState, VerifyFun) ->
 	    verify_fun(OtpCert, {bad_cert, invalid_issuer}, UserState, VerifyFun)
     end. 
 %%--------------------------------------------------------------------
--spec validate_signature(#'OTPCertificate'{}, der_encoded(),
+-spec validate_signature(#'OTPCertificate'{}, DER::binary(),
 			 term(),term(), term(), fun()) -> term().
 				
 %%
diff --git a/lib/public_key/src/pubkey_cert_records.erl b/lib/public_key/src/pubkey_cert_records.erl
index 2441cfc0e0..b86d7a1f0c 100644
--- a/lib/public_key/src/pubkey_cert_records.erl
+++ b/lib/public_key/src/pubkey_cert_records.erl
@@ -30,7 +30,7 @@
 %%====================================================================
 
 %%--------------------------------------------------------------------
--spec decode_cert(der_encoded()) -> {ok, #'OTPCertificate'{}}.
+-spec decode_cert(DerCert::binary()) -> {ok, #'OTPCertificate'{}}.
 %%
 %% Description: Recursively decodes a Certificate. 
 %%-------------------------------------------------------------------- 
diff --git a/lib/public_key/src/pubkey_pem.erl b/lib/public_key/src/pubkey_pem.erl
index c8c69bcdd0..c26815bc04 100644
--- a/lib/public_key/src/pubkey_pem.erl
+++ b/lib/public_key/src/pubkey_pem.erl
@@ -69,8 +69,9 @@ encode(PemEntries) ->
     encode_pem_entries(PemEntries).
 
 %%--------------------------------------------------------------------
--spec decipher({pki_asn1_type(), decrypt_der(),{Cipher :: string(), Salt :: binary()}}, string()) ->  
-		      der_encoded().
+-spec decipher({pki_asn1_type(), DerEncrypted::binary(),{Cipher :: string(),
+							 Salt :: binary()}},
+	       string()) -> Der::binary().
 %%
 %% Description: Deciphers a decrypted pem entry.
 %%--------------------------------------------------------------------
@@ -78,7 +79,8 @@ decipher({_, DecryptDer, {Cipher,Salt}}, Password) ->
     decode_key(DecryptDer, Password, Cipher, Salt).	
 
 %%--------------------------------------------------------------------
--spec cipher(der_encoded(),{Cipher :: string(), Salt :: binary()} , string()) -> binary().
+-spec cipher(Der::binary(),{Cipher :: string(), Salt :: binary()} ,
+	     string()) -> binary().
 %%
 %% Description: Ciphers a PEM entry
 %%--------------------------------------------------------------------
@@ -91,11 +93,11 @@ cipher(Der, {Cipher,Salt}, Password)->
 encode_pem_entries(Entries) ->
     [encode_pem_entry(Entry) || Entry <- Entries].
 
-encode_pem_entry({Asn1Type, Der, not_encrypted}) ->
-    StartStr = pem_start(Asn1Type),
+encode_pem_entry({Type, Der, not_encrypted}) ->
+    StartStr = pem_start(Type),
     [StartStr, "\n", b64encode_and_split(Der), "\n", pem_end(StartStr) ,"\n\n"];
-encode_pem_entry({Asn1Type, Der, {Cipher, Salt}}) ->
-    StartStr = pem_start(Asn1Type),
+encode_pem_entry({Type, Der, {Cipher, Salt}}) ->
+    StartStr = pem_start(Type),
     [StartStr,"\n", pem_decrypt(),"\n", pem_decrypt_info(Cipher, Salt),"\n",
      b64encode_and_split(Der), "\n", pem_end(StartStr) ,"\n\n"].
 
@@ -115,17 +117,17 @@ decode_pem_entries([Start| Lines], Entries) ->
     end.
 
 decode_pem_entry(Start, [<<"Proc-Type: 4,ENCRYPTED", _/binary>>, Line | Lines]) ->
-    Asn1Type = asn1_type(Start),
+    Type = asn1_type(Start),
     Cs = erlang:iolist_to_binary(Lines),
     Decoded = base64:mime_decode(Cs),
     [_, DekInfo0] = string:tokens(binary_to_list(Line), ": "),
     [Cipher, Salt] = string:tokens(DekInfo0, ","), 
-    {Asn1Type, Decoded, {Cipher, unhex(Salt)}};
+    {Type, Decoded, {Cipher, unhex(Salt)}};
 decode_pem_entry(Start, Lines) ->
-    Asn1Type = asn1_type(Start),
+    Type = asn1_type(Start),
     Cs = erlang:iolist_to_binary(Lines),
-    Der = base64:mime_decode(Cs),
-    {Asn1Type, Der, not_encrypted}.
+    Decoded = base64:mime_decode(Cs),
+    {Type, Decoded, not_encrypted}.
     
 split_bin(Bin) ->
     split_bin(0, Bin).
@@ -153,17 +155,7 @@ split_lines(Bin) ->
     [Bin].
 
 %% Ignore white space at end of line
-join_entry([<<"-----END CERTIFICATE-----", _/binary>>| Lines], Entry) ->
-    {lists:reverse(Entry), Lines};
-join_entry([<<"-----END RSA PRIVATE KEY-----", _/binary>>| Lines], Entry) ->
-    {lists:reverse(Entry), Lines};
-join_entry([<<"-----END PUBLIC KEY-----", _/binary>>| Lines], Entry) ->
-    {lists:reverse(Entry), Lines};
-join_entry([<<"-----END RSA PUBLIC KEY-----", _/binary>>| Lines], Entry) ->
-    {lists:reverse(Entry), Lines};
-join_entry([<<"-----END DSA PRIVATE KEY-----", _/binary>>| Lines], Entry) ->
-    {lists:reverse(Entry), Lines};
-join_entry([<<"-----END DH PARAMETERS-----", _/binary>>| Lines], Entry) ->
+join_entry([<<"-----END ", _/binary>>| Lines], Entry) ->
     {lists:reverse(Entry), Lines};
 join_entry([Line | Lines], Entry) ->
     join_entry(Lines, [Line | Entry]).
diff --git a/lib/public_key/src/pubkey_ssh.erl b/lib/public_key/src/pubkey_ssh.erl
new file mode 100644
index 0000000000..f342eab159
--- /dev/null
+++ b/lib/public_key/src/pubkey_ssh.erl
@@ -0,0 +1,431 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2011-2011. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(pubkey_ssh).
+
+-include("public_key.hrl").
+
+-export([decode/2, encode/2]).
+
+-define(UINT32(X), X:32/unsigned-big-integer).
+%% Max encoded line length is 72, but conformance examples use 68
+%% Comment from rfc 4716: "The following are some examples of public
+%% key files that are compliant (note that the examples all wrap
+%% before 72 bytes to meet IETF document requirements; however, they
+%% are still compliant.)" So we choose to use 68 also.
+-define(ENCODED_LINE_LENGTH, 68).
+
+%%====================================================================
+%% Internal application API
+%%====================================================================
+
+%%--------------------------------------------------------------------
+-spec decode(binary(), public_key | ssh_file()) -> [{public_key(), Attributes::list()}].
+%%
+%% Description: Decodes a ssh file-binary.
+%%--------------------------------------------------------------------
+decode(Bin, public_key)->
+    case binary:match(Bin, begin_marker()) of
+	nomatch ->
+	    openssh_decode(Bin, openssh_public_key);
+	_ ->
+	    rfc4716_decode(Bin)
+    end;
+decode(Bin, rfc4716_public_key) ->
+     rfc4716_decode(Bin);
+decode(Bin, Type) ->
+    openssh_decode(Bin, Type).
+
+%%--------------------------------------------------------------------
+-spec encode([{public_key(), Attributes::list()}], ssh_file()) ->
+		    binary().
+%%
+%% Description: Encodes a list of ssh file entries.
+%%--------------------------------------------------------------------
+encode(Entries, Type) ->
+    erlang:iolist_to_binary(lists:map(fun({Key, Attributes}) ->
+					      do_encode(Type, Key, Attributes)
+				      end, Entries)).
+
+%%--------------------------------------------------------------------
+%%% Internal functions
+%%--------------------------------------------------------------------
+begin_marker() ->
+    <<"---- BEGIN SSH2 PUBLIC KEY ----">>.
+end_marker() ->
+    <<"---- END SSH2 PUBLIC KEY ----">>.
+
+rfc4716_decode(Bin) ->
+    Lines = binary:split(Bin, <<"\n">>, [global]),
+    do_rfc4716_decode(Lines, []).
+
+do_rfc4716_decode([<<"---- BEGIN SSH2 PUBLIC KEY ----", _/binary>> | Lines], Acc) ->
+    do_rfc4716_decode(Lines, Acc);
+%% Ignore empty lines before or after begin/end - markers.
+do_rfc4716_decode([<<>> | Lines], Acc) ->
+    do_rfc4716_decode(Lines, Acc);
+do_rfc4716_decode([], Acc) ->
+    lists:reverse(Acc);
+do_rfc4716_decode(Lines, Acc) ->
+    {Headers, PubKey, Rest} = rfc4716_decode_lines(Lines, []),
+    case Headers of
+	[_|_] ->
+	    do_rfc4716_decode(Rest, [{PubKey, [{headers, Headers}]} | Acc]);
+	_  ->
+	    do_rfc4716_decode(Rest, [{PubKey, []} | Acc])
+    end.
+
+rfc4716_decode_lines([Line | Lines], Acc) ->
+    case binary:last(Line) of
+	$\\ ->
+	    NewLine = binary:replace(Line,<<"\\">>, hd(Lines), []),
+	    rfc4716_decode_lines([NewLine | tl(Lines)], Acc);
+	_ ->
+	    rfc4716_decode_line(Line, Lines, Acc)
+    end.
+
+rfc4716_decode_line(Line, Lines, Acc) ->
+    case binary:split(Line, <<":">>) of
+	[Tag, Value] ->
+	    rfc4716_decode_lines(Lines, [{string_decode(Tag), unicode_decode(Value)} | Acc]);
+	_ ->
+	    {Body, Rest} = join_entry([Line | Lines], []),
+	    {lists:reverse(Acc), rfc4716_pubkey_decode(base64:mime_decode(Body)), Rest}
+      end.
+
+join_entry([<<"---- END SSH2 PUBLIC KEY ----", _/binary>>| Lines], Entry) ->
+    {lists:reverse(Entry), Lines};
+join_entry([Line | Lines], Entry) ->
+    join_entry(Lines, [Line | Entry]).
+
+
+rfc4716_pubkey_decode(<<?UINT32(Len), Type:Len/binary,
+	      ?UINT32(SizeE), E:SizeE/binary,
+	      ?UINT32(SizeN), N:SizeN/binary>>) when Type == <<"ssh-rsa">> ->
+    #'RSAPublicKey'{modulus = erlint(SizeN, N),
+		    publicExponent = erlint(SizeE, E)};
+
+rfc4716_pubkey_decode(<<?UINT32(Len), Type:Len/binary,
+	      ?UINT32(SizeP), P:SizeP/binary,
+	      ?UINT32(SizeQ), Q:SizeQ/binary,
+	      ?UINT32(SizeG), G:SizeG/binary,
+	      ?UINT32(SizeY), Y:SizeY/binary>>) when Type == <<"ssh-dss">> ->
+    {erlint(SizeY, Y),
+     #'Dss-Parms'{p = erlint(SizeP, P),
+		  q = erlint(SizeQ, Q),
+		  g = erlint(SizeG, G)}}.
+
+openssh_decode(Bin, FileType) ->
+    Lines = binary:split(Bin, <<"\n">>, [global]),
+    do_openssh_decode(FileType, Lines, []).
+
+do_openssh_decode(_, [], Acc) ->
+    lists:reverse(Acc);
+%% Ignore empty lines
+do_openssh_decode(FileType, [<<>> | Lines], Acc) ->
+    do_openssh_decode(FileType, Lines, Acc);
+%% Ignore lines that start with #
+do_openssh_decode(FileType,[<<"#", _/binary>> | Lines], Acc) ->
+    do_openssh_decode(FileType, Lines, Acc);
+do_openssh_decode(auth_keys = FileType, [Line | Lines], Acc) ->
+    Split = binary:split(Line, <<" ">>, [global]),
+    case mend_split(Split, []) of
+	%% ssh2
+	[Options, KeyType, Base64Enc, Comment] when KeyType == <<"ssh-rsa">>;
+						     KeyType == <<"ssh-dss">> ->
+	    do_openssh_decode(FileType, Lines,
+			      [{openssh_pubkey_decode(KeyType, Base64Enc),
+				[{comment, string_decode(Comment)},
+				 {options, comma_list_decode(Options)}]}
+			       | Acc]);
+
+	[KeyType, Base64Enc, Comment] when KeyType == <<"ssh-rsa">>;
+					    KeyType == <<"ssh-dss">> ->
+	    do_openssh_decode(FileType, Lines,
+			      [{openssh_pubkey_decode(KeyType, Base64Enc),
+				[{comment, string_decode(Comment)}]} | Acc]);
+	%% ssh1
+	[Options, Bits, Exponent, Modulus, Comment] ->
+	    do_openssh_decode(FileType, Lines,
+			      [{ssh1_rsa_pubkey_decode(Modulus, Exponent),
+				[{comment, string_decode(Comment)},
+				 {options, comma_list_decode(Options)},
+				 {bits, integer_decode(Bits)}]} | Acc]);
+	[Bits, Exponent, Modulus, Comment]  ->
+	    do_openssh_decode(FileType, Lines,
+			      [{ssh1_rsa_pubkey_decode(Modulus, Exponent),
+				[{comment, string_decode(Comment)},
+				 {bits, integer_decode(Bits)}]} | Acc])
+	end;
+
+do_openssh_decode(known_hosts = FileType, [Line | Lines], Acc) ->
+    case binary:split(Line, <<" ">>, [global]) of
+	%% ssh 2
+	[HostNames, KeyType, Base64Enc] when KeyType == <<"ssh-rsa">>;
+					     KeyType == <<"ssh-dss">> ->
+	    do_openssh_decode(FileType, Lines,
+			      [{openssh_pubkey_decode(KeyType, Base64Enc),
+				[{hostnames, comma_list_decode(HostNames)}]}| Acc]);
+	[HostNames, KeyType, Base64Enc, Comment] when KeyType == <<"ssh-rsa">>;
+						       KeyType == <<"ssh-dss">> ->
+	    do_openssh_decode(FileType, Lines,
+			      [{openssh_pubkey_decode(KeyType, Base64Enc),
+				[{comment, string_decode(Comment)},
+				 {hostnames, comma_list_decode(HostNames)}]} | Acc]);
+	%% ssh 1
+	[HostNames, Bits, Exponent, Modulus, Comment] ->
+	    do_openssh_decode(FileType, Lines,
+			      [{ssh1_rsa_pubkey_decode(Modulus, Exponent),
+				[{comment, string_decode(Comment)},
+				 {hostnames, comma_list_decode(HostNames)},
+				 {bits, integer_decode(Bits)}]} | Acc]);
+	[HostNames, Bits, Exponent, Modulus]  ->
+	    do_openssh_decode(FileType, Lines,
+			      [{ssh1_rsa_pubkey_decode(Modulus, Exponent),
+				[{comment, []},
+				 {hostnames, comma_list_decode(HostNames)},
+				 {bits, integer_decode(Bits)}]} | Acc])
+	end;
+
+do_openssh_decode(openssh_public_key = FileType, [Line | Lines], Acc) ->
+    case binary:split(Line, <<" ">>, [global]) of
+	[KeyType, Base64Enc, Comment0] when KeyType == <<"ssh-rsa">>;
+					    KeyType == <<"ssh-dss">> ->
+	    Comment = string:strip(binary_to_list(Comment0), right, $\n),
+	    do_openssh_decode(FileType, Lines,
+			      [{openssh_pubkey_decode(KeyType, Base64Enc),
+				[{comment, Comment}]} | Acc])
+    end.
+
+
+openssh_pubkey_decode(<<"ssh-rsa">>, Base64Enc) ->
+    <<?UINT32(StrLen), _:StrLen/binary,
+      ?UINT32(SizeE), E:SizeE/binary,
+      ?UINT32(SizeN), N:SizeN/binary>>
+	= base64:mime_decode(Base64Enc),
+    #'RSAPublicKey'{modulus = erlint(SizeN, N),
+		    publicExponent = erlint(SizeE, E)};
+
+openssh_pubkey_decode(<<"ssh-dss">>, Base64Enc) ->
+    <<?UINT32(StrLen), _:StrLen/binary,
+      ?UINT32(SizeP), P:SizeP/binary,
+      ?UINT32(SizeQ), Q:SizeQ/binary,
+      ?UINT32(SizeG), G:SizeG/binary,
+      ?UINT32(SizeY), Y:SizeY/binary>>
+	= base64:mime_decode(Base64Enc),
+    {erlint(SizeY, Y),
+     #'Dss-Parms'{p = erlint(SizeP, P),
+		  q = erlint(SizeQ, Q),
+		  g = erlint(SizeG, G)}}.
+
+erlint(MPIntSize, MPIntValue) ->
+    Bits= MPIntSize * 8,
+    <<Integer:Bits/integer>> = MPIntValue,
+    Integer.
+
+ssh1_rsa_pubkey_decode(MBin, EBin) ->
+    #'RSAPublicKey'{modulus = integer_decode(MBin),
+		    publicExponent = integer_decode(EBin)}.
+
+integer_decode(BinStr) ->
+    list_to_integer(binary_to_list(BinStr)).
+
+string_decode(BinStr) ->
+    binary_to_list(BinStr).
+
+unicode_decode(BinStr) ->
+    unicode:characters_to_list(BinStr).
+
+comma_list_decode(BinOpts) ->
+    CommaList = binary:split(BinOpts, <<",">>, [global]),
+    lists:map(fun(Item) ->
+		      binary_to_list(Item)
+	      end, CommaList).
+
+do_encode(rfc4716_public_key, Key, Attributes) ->
+    rfc4716_encode(Key, proplists:get_value(headers, Attributes, []), []);
+
+do_encode(Type, Key, Attributes) ->
+    openssh_encode(Type, Key, Attributes).
+
+rfc4716_encode(Key, [],[]) ->
+    erlang:iolist_to_binary([begin_marker(),"\n",
+			     split_lines(base64:encode(ssh2_pubkey_encode(Key))),
+			     "\n", end_marker(), "\n"]);
+rfc4716_encode(Key, [], [_|_] = Acc) ->
+    erlang:iolist_to_binary([begin_marker(), "\n",
+			     lists:reverse(Acc),
+			     split_lines(base64:encode(ssh2_pubkey_encode(Key))),
+			     "\n", end_marker(), "\n"]);
+rfc4716_encode(Key, [ Header | Headers], Acc) ->
+    LinesStr = rfc4716_encode_header(Header),
+    rfc4716_encode(Key, Headers, [LinesStr | Acc]).
+
+rfc4716_encode_header({Tag, Value}) ->
+    TagLen = length(Tag),
+    ValueLen = length(Value),
+    case TagLen + 1 + ValueLen of
+	N when N > ?ENCODED_LINE_LENGTH ->
+	    NumOfChars =  ?ENCODED_LINE_LENGTH - (TagLen + 1),
+	    {First, Rest} = lists:split(NumOfChars, Value),
+	    [Tag,":" , First, [$\\], "\n", rfc4716_encode_value(Rest) , "\n"];
+	_ ->
+	    [Tag, ":", Value, "\n"]
+    end.
+
+rfc4716_encode_value(Value) ->
+    case length(Value) of
+	N when N > ?ENCODED_LINE_LENGTH ->
+	    {First, Rest} = lists:split(?ENCODED_LINE_LENGTH, Value),
+	    [First, [$\\], "\n", rfc4716_encode_value(Rest)];
+	_ ->
+	    Value
+    end.
+
+openssh_encode(openssh_public_key, Key, Attributes) ->
+    Comment = proplists:get_value(comment, Attributes),
+    Enc = base64:encode(ssh2_pubkey_encode(Key)),
+    erlang:iolist_to_binary([key_type(Key), " ",  Enc,  " ", Comment, "\n"]);
+
+openssh_encode(auth_keys, Key, Attributes) ->
+    Comment = proplists:get_value(comment, Attributes, ""),
+    Options = proplists:get_value(options, Attributes, undefined),
+    Bits = proplists:get_value(bits, Attributes, undefined),
+    case Bits of
+	undefined ->
+	    openssh_ssh2_auth_keys_encode(Options, Key, Comment);
+	_ ->
+	    openssh_ssh1_auth_keys_encode(Options, Bits, Key, Comment)
+    end;
+openssh_encode(known_hosts, Key, Attributes) ->
+    Comment = proplists:get_value(comment, Attributes, ""),
+    Hostnames = proplists:get_value(hostnames, Attributes),
+    Bits = proplists:get_value(bits, Attributes, undefined),
+    case Bits of
+	undefined ->
+	    openssh_ssh2_know_hosts_encode(Hostnames, Key, Comment);
+	_ ->
+	    openssh_ssh1_known_hosts_encode(Hostnames, Bits, Key, Comment)
+    end.
+
+openssh_ssh2_auth_keys_encode(undefined, Key, Comment) ->
+    erlang:iolist_to_binary([key_type(Key)," ",  base64:encode(ssh2_pubkey_encode(Key)), line_end(Comment)]);
+openssh_ssh2_auth_keys_encode(Options, Key, Comment) ->
+    erlang:iolist_to_binary([comma_list_encode(Options, []), " ",
+			     key_type(Key)," ", base64:encode(ssh2_pubkey_encode(Key)), line_end(Comment)]).
+
+openssh_ssh1_auth_keys_encode(undefined, Bits,
+			      #'RSAPublicKey'{modulus = N, publicExponent = E},
+			      Comment) ->
+    erlang:iolist_to_binary([integer_to_list(Bits), " ", integer_to_list(E), " ", integer_to_list(N),
+			     line_end(Comment)]);
+openssh_ssh1_auth_keys_encode(Options, Bits,
+			      #'RSAPublicKey'{modulus = N, publicExponent = E},
+			      Comment) ->
+    erlang:iolist_to_binary([comma_list_encode(Options, []), " ", integer_to_list(Bits),
+			     " ", integer_to_list(E), " ", integer_to_list(N), line_end(Comment)]).
+
+openssh_ssh2_know_hosts_encode(Hostnames, Key, Comment) ->
+    erlang:iolist_to_binary([comma_list_encode(Hostnames, []), " ",
+			     key_type(Key)," ",  base64:encode(ssh2_pubkey_encode(Key)), line_end(Comment)]).
+
+openssh_ssh1_known_hosts_encode(Hostnames, Bits,
+			      #'RSAPublicKey'{modulus = N, publicExponent = E},
+			      Comment) ->
+    erlang:iolist_to_binary([comma_list_encode(Hostnames, [])," ", integer_to_list(Bits)," ",
+			     integer_to_list(E)," ", integer_to_list(N), line_end(Comment)]).
+
+line_end("") ->
+    "\n";
+line_end(Comment) ->
+    [" ", Comment, "\n"].
+
+key_type(#'RSAPublicKey'{}) ->
+    <<"ssh-rsa">>;
+key_type({_, #'Dss-Parms'{}}) ->
+    <<"ssh-dss">>.
+
+comma_list_encode([Option], [])  ->
+    Option;
+comma_list_encode([Option], Acc) ->
+    Acc ++ "," ++ Option;
+comma_list_encode([Option | Rest], []) ->
+    comma_list_encode(Rest, Option);
+comma_list_encode([Option | Rest], Acc) ->
+    comma_list_encode(Rest, Acc ++ "," ++ Option).
+
+ssh2_pubkey_encode(#'RSAPublicKey'{modulus = N, publicExponent = E}) ->
+    TypeStr = <<"ssh-rsa">>,
+    StrLen = size(TypeStr),
+    EBin = crypto:mpint(E),
+    NBin = crypto:mpint(N),
+    <<?UINT32(StrLen), TypeStr:StrLen/binary,
+      EBin/binary,
+      NBin/binary>>;
+ssh2_pubkey_encode({Y,  #'Dss-Parms'{p = P, q = Q, g = G}}) ->
+    TypeStr = <<"ssh-dss">>,
+    StrLen = size(TypeStr),
+    PBin = crypto:mpint(P),
+    QBin = crypto:mpint(Q),
+    GBin = crypto:mpint(G),
+    YBin = crypto:mpint(Y),
+    <<?UINT32(StrLen), TypeStr:StrLen/binary,
+      PBin/binary,
+      QBin/binary,
+      GBin/binary,
+      YBin/binary>>.
+
+mend_split([Part1, Part2 | Rest] = List, Acc) ->
+    case option_end(Part1, Part2) of
+	true ->
+	    lists:reverse(Acc) ++ List;
+	false ->
+	    case length(binary:matches(Part1, <<"\"">>)) of
+		N  when N rem 2 == 0 ->
+		    mend_split(Rest, [Part1 | Acc]);
+		_ ->
+		    mend_split([<<Part1/binary, Part2/binary>> | Rest], Acc)
+	    end
+    end.
+
+option_end(Part1, Part2) ->
+    (is_key_field(Part1) orelse is_bits_field(Part1))
+	orelse
+	  (is_key_field(Part2) orelse is_bits_field(Part2)).
+
+is_key_field(<<"ssh-dss">>) ->
+    true;
+is_key_field(<<"ssh-rsa">>) ->
+    true;
+is_key_field(_) ->
+    false.
+
+is_bits_field(Part) ->
+    try list_to_integer(binary_to_list(Part)) of
+	_ ->
+	    true
+    catch _:_ ->
+	    false
+    end.
+
+split_lines(<<Text:?ENCODED_LINE_LENGTH/binary>>) ->
+    [Text];
+split_lines(<<Text:?ENCODED_LINE_LENGTH/binary, Rest/binary>>) ->
+    [Text, $\n | split_lines(Rest)];
+split_lines(Bin) ->
+    [Bin].
diff --git a/lib/public_key/src/public_key.app.src b/lib/public_key/src/public_key.app.src
index 60487946fa..1963bd05d4 100644
--- a/lib/public_key/src/public_key.app.src
+++ b/lib/public_key/src/public_key.app.src
@@ -1,9 +1,9 @@
 {application, public_key,
   [{description, "Public key infrastructure"},
    {vsn, "%VSN%"},
-   {modules, [
-	          public_key,
-		  pubkey_pem, 
+   {modules, [	  public_key,
+		  pubkey_pem,
+		  pubkey_ssh,
 		  pubkey_cert,
 		  pubkey_cert_records,
 		  'OTP-PUB-KEY'
diff --git a/lib/public_key/src/public_key.erl b/lib/public_key/src/public_key.erl
index 7e022da7e5..2901020e83 100644
--- a/lib/public_key/src/public_key.erl
+++ b/lib/public_key/src/public_key.erl
@@ -41,7 +41,8 @@
 	 pkix_is_issuer/2,
 	 pkix_issuer_id/2,
 	 pkix_normalize_name/1,
-	 pkix_path_validation/3
+	 pkix_path_validation/3,
+	 ssh_decode/2, ssh_encode/2
 	]).
 
 %% Deprecated
@@ -51,10 +52,6 @@
 -deprecated({decode_private_key, 1, next_major_release}).
 -deprecated({decode_private_key, 2, next_major_release}).
 
--type rsa_public_key()       ::  #'RSAPublicKey'{}.
--type rsa_private_key()      ::  #'RSAPrivateKey'{}.
--type dsa_private_key()      ::  #'DSAPrivateKey'{}.
--type dsa_public_key()       :: {integer(), #'Dss-Parms'{}}.
 -type rsa_padding()          :: 'rsa_pkcs1_padding' | 'rsa_pkcs1_oaep_padding' 
 			      | 'rsa_no_padding'.
 -type public_crypt_options() :: [{rsa_pad, rsa_padding()}].
@@ -67,7 +64,6 @@
 %%====================================================================
 %% API
 %%====================================================================
-
 %%--------------------------------------------------------------------
 -spec pem_decode(binary()) -> [pem_entry()].
 %%
@@ -152,7 +148,7 @@ pem_entry_encode(Asn1Type, Entity,
     {Asn1Type, DecryptDer, CipherInfo}.
 
 %%--------------------------------------------------------------------
--spec der_decode(asn1_type(), der_encoded()) -> term().
+-spec der_decode(asn1_type(), Der::binary()) -> term().
 %%
 %% Description: Decodes a public key asn1 der encoded entity.
 %%--------------------------------------------------------------------
@@ -166,7 +162,7 @@ der_decode(Asn1Type, Der) when is_atom(Asn1Type), is_binary(Der) ->
     end.
 
 %%--------------------------------------------------------------------
--spec der_encode(asn1_type(), term()) -> der_encoded().
+-spec der_encode(asn1_type(), term()) -> Der::binary().
 %%
 %% Description: Encodes a public key entity with asn1 DER encoding.
 %%--------------------------------------------------------------------
@@ -180,7 +176,7 @@ der_encode(Asn1Type, Entity) when is_atom(Asn1Type) ->
     end.
 
 %%--------------------------------------------------------------------
--spec pkix_decode_cert(der_encoded(), plain | otp) -> 
+-spec pkix_decode_cert(Cert::binary(), plain | otp) ->
 			      #'Certificate'{} | #'OTPCertificate'{}.
 %%
 %% Description: Decodes an asn1 der encoded pkix certificate. The otp
@@ -201,7 +197,7 @@ pkix_decode_cert(DerCert, otp) when is_binary(DerCert) ->
     end.
 
 %%--------------------------------------------------------------------
--spec pkix_encode(asn1_type(), term(), otp | plain) -> der_encoded().
+-spec pkix_encode(asn1_type(), term(), otp | plain) -> Der::binary().
 %%
 %% Description: Der encodes a certificate or part of a certificate.
 %% This function must be used for encoding certificates or parts of certificates
@@ -361,7 +357,7 @@ verify(PlainText, sha, Signature, {Key,  #'Dss-Parms'{p = P, q = Q, g = G}})
 		       crypto:mpint(G), crypto:mpint(Key)]).
 %%--------------------------------------------------------------------
 -spec pkix_sign(#'OTPTBSCertificate'{},
-		rsa_private_key() | dsa_private_key()) -> der_encoded().
+		rsa_private_key() | dsa_private_key()) -> Der::binary().
 %%
 %% Description: Sign a pkix x.509 certificate. Returns the corresponding
 %% der encoded 'Certificate'{}
@@ -370,7 +366,7 @@ pkix_sign(#'OTPTBSCertificate'{signature =
 				   #'SignatureAlgorithm'{algorithm = Alg} 
 			       = SigAlg} = TBSCert, Key) ->
 
-    Msg = pkix_encode('OTPTBSCertificate', TBSCert, otp),    
+    Msg = pkix_encode('OTPTBSCertificate', TBSCert, otp),
     DigestType = pubkey_cert:digest_type(Alg),
     Signature = sign(Msg, DigestType, Key),
     Cert = #'OTPCertificate'{tbsCertificate= TBSCert,
@@ -380,7 +376,7 @@ pkix_sign(#'OTPTBSCertificate'{signature =
     pkix_encode('OTPCertificate', Cert, otp).
 
 %%--------------------------------------------------------------------
--spec pkix_verify(der_encoded(), rsa_public_key()| 
+-spec pkix_verify(Cert::binary(), rsa_public_key()|
 		  dsa_public_key()) -> boolean().
 %%
 %% Description: Verify pkix x.509 certificate signature.
@@ -396,9 +392,9 @@ pkix_verify(DerCert,  #'RSAPublicKey'{} = RSAKey)
     verify(PlainText, DigestType, Signature, RSAKey).
 
 %%--------------------------------------------------------------------
--spec pkix_is_issuer(Cert :: der_encoded()| #'OTPCertificate'{},
-		     IssuerCert :: der_encoded()| 
-				   #'OTPCertificate'{}) -> boolean().
+-spec pkix_is_issuer(Cert::binary()| #'OTPCertificate'{},
+		     IssuerCert::binary()|
+				 #'OTPCertificate'{}) -> boolean().
 %%
 %% Description: Checks if <IssuerCert> issued <Cert>.
 %%--------------------------------------------------------------------
@@ -414,7 +410,7 @@ pkix_is_issuer(#'OTPCertificate'{tbsCertificate = TBSCert},
 			  Candidate#'OTPTBSCertificate'.subject).
 
 %%--------------------------------------------------------------------
--spec pkix_is_self_signed(der_encoded()| #'OTPCertificate'{}) -> boolean().
+-spec pkix_is_self_signed(Cert::binary()| #'OTPCertificate'{}) -> boolean().
 %%
 %% Description: Checks if a Certificate is self signed. 
 %%--------------------------------------------------------------------
@@ -425,7 +421,7 @@ pkix_is_self_signed(Cert) when is_binary(Cert) ->
     pkix_is_self_signed(OtpCert).
   
 %%--------------------------------------------------------------------
--spec pkix_is_fixed_dh_cert(der_encoded()| #'OTPCertificate'{}) -> boolean().
+-spec pkix_is_fixed_dh_cert(Cert::binary()| #'OTPCertificate'{}) -> boolean().
 %%
 %% Description: Checks if a Certificate is a fixed Diffie-Hellman Cert.
 %%--------------------------------------------------------------------
@@ -436,14 +432,14 @@ pkix_is_fixed_dh_cert(Cert) when is_binary(Cert) ->
     pkix_is_fixed_dh_cert(OtpCert).
 
 %%--------------------------------------------------------------------
--spec pkix_issuer_id(der_encoded()| #'OTPCertificate'{}, 
-		     IssuedBy :: self | other) -> 
-			    {ok, {SerialNr :: integer(), 
-				  Issuer :: {rdnSequence, 
-					     [#'AttributeTypeAndValue'{}]}}} 
+-spec pkix_issuer_id(Cert::binary()| #'OTPCertificate'{},
+		     IssuedBy :: self | other) ->
+			    {ok, {SerialNr :: integer(),
+				  Issuer :: {rdnSequence,
+					     [#'AttributeTypeAndValue'{}]}}}
 				| {error, Reason :: term()}.
 %
-%% Description: Returns the issuer id.  
+%% Description: Returns the issuer id.
 %%--------------------------------------------------------------------
 pkix_issuer_id(#'OTPCertificate'{} = OtpCert, self) ->
     pubkey_cert:issuer_id(OtpCert, self);
@@ -456,8 +452,8 @@ pkix_issuer_id(Cert, Signed) when is_binary(Cert) ->
     pkix_issuer_id(OtpCert, Signed).
 
 %%--------------------------------------------------------------------
--spec pkix_normalize_name({rdnSequence, 
-				   [#'AttributeTypeAndValue'{}]}) -> 
+-spec pkix_normalize_name({rdnSequence,
+				   [#'AttributeTypeAndValue'{}]}) ->
 					 {rdnSequence, 
 					  [#'AttributeTypeAndValue'{}]}.
 %%
@@ -468,8 +464,8 @@ pkix_normalize_name(Issuer) ->
     pubkey_cert:normalize_general_name(Issuer).
 
 %%-------------------------------------------------------------------- 
--spec pkix_path_validation(der_encoded()| #'OTPCertificate'{} | atom(),
-			   CertChain :: [der_encoded()] , 
+-spec pkix_path_validation(Cert::binary()| #'OTPCertificate'{} | atom(),
+			   CertChain :: [binary()] ,
 			   Options :: list()) ->  
 				  {ok, {PublicKeyInfo :: term(), 
 					PolicyTree :: term()}} |
@@ -496,7 +492,7 @@ pkix_path_validation(TrustedCert, CertChain, Options) when
   is_binary(TrustedCert) -> OtpCert = pkix_decode_cert(TrustedCert,
   otp), pkix_path_validation(OtpCert, CertChain, Options);
 
-pkix_path_validation(#'OTPCertificate'{} = TrustedCert, CertChain, Options) 
+pkix_path_validation(#'OTPCertificate'{} = TrustedCert, CertChain, Options)
   when is_list(CertChain), is_list(Options) ->
     MaxPathDefault = length(CertChain),
     ValidationState = pubkey_cert:init_validation_state(TrustedCert, 
@@ -505,6 +501,37 @@ pkix_path_validation(#'OTPCertificate'{} = TrustedCert, CertChain, Options)
     path_validation(CertChain, ValidationState).
 
 %%--------------------------------------------------------------------
+-spec ssh_decode(binary(), public_key | ssh_file()) -> [{public_key(), Attributes::list()}].
+%%
+%% Description: Decodes a ssh file-binary. In the case of know_hosts
+%% or auth_keys the binary may include one or more lines of the
+%% file. Returns a list of public keys and their attributes, possible
+%% attribute values depends on the file type represented by the
+%% binary.
+%%--------------------------------------------------------------------
+ssh_decode(SshBin, Type) when is_binary(SshBin),
+			      Type == public_key;
+			      Type == rfc4716_public_key;
+			      Type == openssh_public_key;
+			      Type == auth_keys;
+			      Type == known_hosts ->
+    pubkey_ssh:decode(SshBin, Type).
+
+%%--------------------------------------------------------------------
+-spec ssh_encode([{public_key(), Attributes::list()}], ssh_file()) ->
+			binary().
+%% Description: Encodes a list of ssh file entries (public keys and
+%% attributes) to a binary. Possible attributes depends on the file
+%% type.
+%%--------------------------------------------------------------------
+ssh_encode(Entries, Type) when is_list(Entries),
+			       Type == rfc4716_public_key;
+			       Type == openssh_public_key;
+			       Type == auth_keys;
+			       Type == known_hosts ->
+    pubkey_ssh:encode(Entries, Type).
+
+%%--------------------------------------------------------------------
 %%% Internal functions
 %%--------------------------------------------------------------------
 
@@ -518,7 +545,6 @@ decrypt_public(CipherText, N,E, Options) ->
     crypto:rsa_public_decrypt(CipherText,[crypto:mpint(E), crypto:mpint(N)], 
 			      Padding).
 
-
 path_validation([], #path_validation_state{working_public_key_algorithm
 					   = Algorithm,
 					   working_public_key =