michaellou
- 浏览: 56065 次
- 性别:
- 来自: 上海
-
文章分类
最新评论
-
michaellou：
www.hyoogo.com
淘宝(taobao)HSF框架 -
michaellou：
自己顶！【hyoogo.com】
淘宝(taobao)HSF框架 -
56553655：
很好的优化经验，值得借鉴
QQ.com速度优化解决方案介绍 -
gmingsoft04：
重新排版了一下
package ssh;
impor ...
java shell ssh -
weiqiancheng88：
2楼的方法可以哦
extJs datastore超时设置
用JAVA调用SSH命令（转）
2009-10-10 22:28
SSH命令使用手册
SSH 的详细使用方法如下：
ssh [-l login_name] [hostname | user@hostname] [command] ssh [-afgknqtvxCPX246] [-c blowfish | 3des] [-e escape_char] [-i identity_file] [-l login_name] [-o option] [-p port] [-L port:host:hostport] [-R port:host:hostport] [hostname | user@hostname] [command]
sshd
为执行 ssh 的 daemon，在读者使用 ssh 之前必须去激活 sshd，在此建议把它加在 /etc/init/rc.local 中，在每次开机时激活。
在执行 sshd 之前可以指定它的 port，例如：sshd –p 999
若有安装 SSL，可以指定 SSL 的 port 443，例如：sshd –p 443
这样就可以经过 SSL 及 SSH 双重的保护，但必须去指明使用的 port
ssh –l user –p 443 mouse.oit.edu.tw 才行，若不指明则仍然使用预设的port 22
ssh
选项：
-l login_name
指定登入于远程机器上的使用者，若没加这个选项，而直接打 ssh lost 也是可以的，它是以读者目前的使用者去做登入的动作。例如： ssh –l shie mouse.oit.edu.tw
-c blowfish|3des
在期间内选择所加密的密码型式。预设是3des，3des(作三次的资料加密) 是用三种不同的密码键作三次的加密-解密-加密。 blowfish 是一个快速区块密码编制器，它比3des更安全以及更快速。
-v
Verbose 模式。使ssh 去印出关于行程的除错讯息，这在连接除错，认 证和设定的问题上有很的帮助。
-V
显示版本。
-a
关闭认证代理联机。
-f
要求ssh 在背景执行命令，假如ssh要询问密码或通行证，但是使用者 想要它在幕后执行就可以用这个方式，最好还是加上-l user 例如在远程场所上激活 X11，有点像是 ssh –f host xterm 。
-e character
设定跳脱字符。
-g
允许远程主机去连接本地指派的 ports。
-i identity_file
选择所读取的 RSA 认证识别的档案。预设是在使用者的家目录 中的 .ssh/identity 。
-n
重导 stdin 到 /dev/null (实际上是避免读取 stdin)。必须当 ssh 在幕后执行时才使用。常见的招数是使用这选项在远程机器上去执行 X11 的程序 例如，ssh -n shadows.cs.hut.fi emacs &，将在 shadows.cs.hut.fi 上激活 emace，并且 X11 连接将自动地在加密的信道上发送。ssh 程序将把它放 在幕后。(假如ssh需要去询问密码时，这将不会动作)
-p port
连接远程机器上的 port。
-P
使用非特定的 port 去对外联机。如果读者的防火墙不淮许从特定的 port去联机时，就可以使用这个选项。注意这个选项会关掉 RhostsAuthentication 和 RhostsRSAAuthentication。
-q
安静模式。把所有的警告和讯息抑制，只有严重的错误才会被显示。
-t
强制配置 pseudo-tty。这可以在远程机器上去执行任意的 screen-based 程 式，例如操作 menu services。
-C
要求压缩所有资料(包含 stdin, stdout,stderr 和 X11 和 TCP/IP 连接) 压缩演算规则与 gzip 相同，但是压缩的等级不能控制。在调制解调器或 联机速度很慢的地方，压缩是个很好的选择，但如果读者的网络速路很 快的话，速度反而会慢下来。
-L listen-port:host:port
指派本地的 port 到达端机器地址上的 port。
-R listen-port:host:port
指派远程上的 port 到本地地址上的 port。
-2 强制 ssh 去使用协议版本 2。
-4 强制 ssh 去使用 IPv4 地址。
-6 强制 ssh 去使用 IPv6 地址。
scp
使用 scp 在远程机器上 copy 档案
例如：
copy 本地的档案到远程的机器上
scp /etc/lilo.conf k@net67.ee.oit.edu.tw:/home/k
会将本地的 /etc/lilo.conf 这个档案 copy 到 net67.ee.oit.edu.tw，使用者 k 的家目录下。
copy远程机器上的档案到本地来
scp k@net67.ee.oit.edu.tw:/etc/lilo.conf /etc
会将 net67.ee.oitdu.tw 中 /etc/lilo.conf 档案 copy 到本地的 /etc 目录下。
保持从来源 host 档案的属性
scp –p k@net67.ee.tw:/etc/lilo.conf /etc
在此必须注意使用者的权限是否可读取远程上的档案，若想知道更多关于 scp 的使用方法，可去看看 scp 的使用手册。
ssh-keygen
产生公开钥 (pulib key) 和私人钥 (private key)，以保障 ssh 联机的安性， 当 ssh 连 shd 服务器，会交换公开钥上，系统会检查 /etc/ssh_know_hosts 内储存的 key，如果找到客户端就用这个 key 产生一个随机产生的session key 传给服务器，两端都用这个 key 来继续完成 ssh 剩下来的阶段。
它会产生 identity.pub、identity 两个档案，私人钥存放于identity，公开钥存放于 identity.pub 中，接下来使用 scp 将 identity.pub copy 到远程机器的家目录下.ssh下的authorized_keys。 .ssh/authorized_keys(这个 authorized_keys 档案相当于协议的 rhosts 档案)，之后使用者能够不用密码去登入。RSA的认证绝对是比 rhosts 认证更来的安全可靠。
执行：
scp identity.pub k@linux1.ee.oit.edu.tw:.ssh/authorized_keys
若在使用 ssh-keygen 产生钥匙对时没有输入密码，则如上所示不需输入密码即可从 net67.ee.oit.edu.tw 去登入 linux1.ee.oit.edu.tw。在此，这里输入的密码可以跟帐号的密码不同，也可以不输入密码。
（2） JAVA与SSH的交互
由于在使用SSH命令时，中间要求输入用户密码，在设计JAVA程序时如果用Runtime的exec方法进行交互，经查证不可行。不过http://www.ganymed.ethz.ch/ssh2/提供了调用ssh和scp命令的jar，通过把用户名和密码传入api中就不需要用户介入输入密码。
从http://www.cjsdn.net/post/view?bid=6&id=173625&tpg=1&ppg=1&sty=1&age=0#173625得到一份示例代码如下：
package com.corp.prj.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.apache.log4j.Logger;
import ch.ethz.ssh2.Connection;
import ch.ethz.ssh2.SCPClient;
import ch.ethz.ssh2.Session;
import ch.ethz.ssh2.StreamGobbler;
/**
* Provides static methods for running SSH, scp as well as local commands.
*
*/
public class CommandRunner {
private static final Logger logger = Logger.getLogger(CommandRunner.class);
private CommandRunner() {
}
/**
* Get remote file through scp
* @param host
* @param username
* @param password
* @param remoteFile
* @param localDir
* @throws IOException
*/
public static void scpGet(String host, String username, String password,
String remoteFile, String localDir) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("spc [" + remoteFile + "] from " + host + " to " + localDir);
}
Connection conn = getOpenedConnection(host, username, password);
SCPClient client = new SCPClient(conn);
client.get(remoteFile, localDir);
conn.close();
}
/**
* Put local file to remote machine.
* @param host
* @param username
* @param password
* @param localFile
* @param remoteDir
* @throws IOException
*/
public static void scpPut(String host, String username, String password,
String localFile, String remoteDir) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("spc [" + localFile + "] to " + host + remoteDir);
}
Connection conn = getOpenedConnection(host, username, password);
SCPClient client = new SCPClient(conn);
client.put(localFile, remoteDir);
conn.close();
}
/**
* Run SSH command.
* @param host
* @param username
* @param password
* @param cmd
* @return exit status
* @throws IOException
*/
public static int runSSH(String host, String username, String password,
String cmd) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("running SSH cmd [" + cmd + "]");
}
Connection conn = getOpenedConnection(host, username, password);
Session sess = conn.openSession();
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
// attention: do not comment this block, or you will hit NullPointerException
// when you are trying to read exit status
String line = br.readLine();
if (line == null)
break;
if (logger.isDebugEnabled()) {
logger.debug(line);
}
}
sess.close();
conn.close();
return sess.getExitStatus().intValue();
}
/**
* return a opened Connection
* @param host
* @param username
* @param password
* @return
* @throws IOException
*/
private static Connection getOpenedConnection(String host, String username,
String password) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("connecting to " + host + " with user " + username
+ " and pwd " + password);
}
Connection conn = new Connection(host);
conn.connect(); // make sure the connection is opened
boolean isAuthenticated = conn.authenticateWithPassword(username,
password);
if (isAuthenticated == false)
throw new IOException("Authentication failed.");
return conn;
}
/**
* Run local command
* @param cmd
* @return exit status
* @throws IOException
*/
public static int runLocal(String cmd) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("running local cmd [" + cmd + "]");
}
Runtime rt = Runtime.getRuntime();
Process p = rt.exec(cmd);
InputStream stdout = new StreamGobbler(p.getInputStream());
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
String line = br.readLine();
if (line == null)
break;
if (logger.isDebugEnabled()) {
logger.debug(line); SSH命令使用手册
SSH 的详细使用方法如下：
ssh [-l login_name] [hostname | user@hostname] [command] ssh [-afgknqtvxCPX246] [-c blowfish | 3des] [-e escape_char] [-i identity_file] [-l login_name] [-o option] [-p port] [-L port:host:hostport] [-R port:host:hostport] [hostname | user@hostname] [command]
sshd
为执行 ssh 的 daemon，在读者使用 ssh 之前必须去激活 sshd，在此建议把它加在 /etc/init/rc.local 中，在每次开机时激活。
在执行 sshd 之前可以指定它的 port，例如：sshd –p 999
若有安装 SSL，可以指定 SSL 的 port 443，例如：sshd –p 443
这样就可以经过 SSL 及 SSH 双重的保护，但必须去指明使用的 port
ssh –l user –p 443 mouse.oit.edu.tw 才行，若不指明则仍然使用预设的port 22
ssh
选项：
-l login_name
指定登入于远程机器上的使用者，若没加这个选项，而直接打 ssh lost 也是可以的，它是以读者目前的使用者去做登入的动作。例如： ssh –l shie mouse.oit.edu.tw
-c blowfish|3des
在期间内选择所加密的密码型式。预设是3des，3des(作三次的资料加密) 是用三种不同的密码键作三次的加密-解密-加密。 blowfish 是一个快速区块密码编制器，它比3des更安全以及更快速。
-v
Verbose 模式。使ssh 去印出关于行程的除错讯息，这在连接除错，认 证和设定的问题上有很的帮助。
-V
显示版本。
-a
关闭认证代理联机。
-f
要求ssh 在背景执行命令，假如ssh要询问密码或通行证，但是使用者 想要它在幕后执行就可以用这个方式，最好还是加上-l user 例如在远程场所上激活 X11，有点像是 ssh –f host xterm 。
-e character
设定跳脱字符。
-g
允许远程主机去连接本地指派的 ports。
-i identity_file
选择所读取的 RSA 认证识别的档案。预设是在使用者的家目录 中的 .ssh/identity 。
-n
重导 stdin 到 /dev/null (实际上是避免读取 stdin)。必须当 ssh 在幕后执行时才使用。常见的招数是使用这选项在远程机器上去执行 X11 的程序 例如，ssh -n shadows.cs.hut.fi emacs &，将在 shadows.cs.hut.fi 上激活 emace，并且 X11 连接将自动地在加密的信道上发送。ssh 程序将把它放 在幕后。(假如ssh需要去询问密码时，这将不会动作)
-p port
连接远程机器上的 port。
-P
使用非特定的 port 去对外联机。如果读者的防火墙不淮许从特定的 port去联机时，就可以使用这个选项。注意这个选项会关掉 RhostsAuthentication 和 RhostsRSAAuthentication。
-q
安静模式。把所有的警告和讯息抑制，只有严重的错误才会被显示。
-t
强制配置 pseudo-tty。这可以在远程机器上去执行任意的 screen-based 程 式，例如操作 menu services。
-C
要求压缩所有资料(包含 stdin, stdout,stderr 和 X11 和 TCP/IP 连接) 压缩演算规则与 gzip 相同，但是压缩的等级不能控制。在调制解调器或 联机速度很慢的地方，压缩是个很好的选择，但如果读者的网络速路很 快的话，速度反而会慢下来。
-L listen-port:host:port
指派本地的 port 到达端机器地址上的 port。
-R listen-port:host:port
指派远程上的 port 到本地地址上的 port。
-2 强制 ssh 去使用协议版本 2。
-4 强制 ssh 去使用 IPv4 地址。
-6 强制 ssh 去使用 IPv6 地址。
scp
使用 scp 在远程机器上 copy 档案
例如：
copy 本地的档案到远程的机器上
scp /etc/lilo.conf k@net67.ee.oit.edu.tw:/home/k
会将本地的 /etc/lilo.conf 这个档案 copy 到 net67.ee.oit.edu.tw，使用者 k 的家目录下。
copy远程机器上的档案到本地来
scp k@net67.ee.oit.edu.tw:/etc/lilo.conf /etc
会将 net67.ee.oitdu.tw 中 /etc/lilo.conf 档案 copy 到本地的 /etc 目录下。
保持从来源 host 档案的属性
scp –p k@net67.ee.tw:/etc/lilo.conf /etc
在此必须注意使用者的权限是否可读取远程上的档案，若想知道更多关于 scp 的使用方法，可去看看 scp 的使用手册。
ssh-keygen
产生公开钥 (pulib key) 和私人钥 (private key)，以保障 ssh 联机的安性， 当 ssh 连 shd 服务器，会交换公开钥上，系统会检查 /etc/ssh_know_hosts 内储存的 key，如果找到客户端就用这个 key 产生一个随机产生的session key 传给服务器，两端都用这个 key 来继续完成 ssh 剩下来的阶段。
它会产生 identity.pub、identity 两个档案，私人钥存放于identity，公开钥存放于 identity.pub 中，接下来使用 scp 将 identity.pub copy 到远程机器的家目录下.ssh下的authorized_keys。 .ssh/authorized_keys(这个 authorized_keys 档案相当于协议的 rhosts 档案)，之后使用者能够不用密码去登入。RSA的认证绝对是比 rhosts 认证更来的安全可靠。
执行：
scp identity.pub k@linux1.ee.oit.edu.tw:.ssh/authorized_keys
若在使用 ssh-keygen 产生钥匙对时没有输入密码，则如上所示不需输入密码即可从 net67.ee.oit.edu.tw 去登入 linux1.ee.oit.edu.tw。在此，这里输入的密码可以跟帐号的密码不同，也可以不输入密码。
（2） JAVA与SSH的交互
由于在使用SSH命令时，中间要求输入用户密码，在设计JAVA程序时如果用Runtime的exec方法进行交互，经查证不可行。不过http://www.ganymed.ethz.ch/ssh2/提供了调用ssh和scp命令的jar，通过把用户名和密码传入api中就不需要用户介入输入密码。
从http://www.cjsdn.net/post/view?bid=6&id=173625&tpg=1&ppg=1&sty=1&age=0#173625得到一份示例代码如下：
package com.corp.prj.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.apache.log4j.Logger;
import ch.ethz.ssh2.Connection;
import ch.ethz.ssh2.SCPClient;
import ch.ethz.ssh2.Session;
import ch.ethz.ssh2.StreamGobbler;
/**
* Provides static methods for running SSH, scp as well as local commands.
*
*/
public class CommandRunner {
private static final Logger logger = Logger.getLogger(CommandRunner.class);
private CommandRunner() {
}
/**
* Get remote file through scp
* @param host
* @param username
* @param password
* @param remoteFile
* @param localDir
* @throws IOException
*/
public static void scpGet(String host, String username, String password,
String remoteFile, String localDir) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("spc [" + remoteFile + "] from " + host + " to " + localDir);
}
Connection conn = getOpenedConnection(host, username, password);
SCPClient client = new SCPClient(conn);
client.get(remoteFile, localDir);
conn.close();
}
/**
* Put local file to remote machine.
* @param host
* @param username
* @param password
* @param localFile
* @param remoteDir
* @throws IOException
*/
public static void scpPut(String host, String username, String password,
String localFile, String remoteDir) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("spc [" + localFile + "] to " + host + remoteDir);
}
Connection conn = getOpenedConnection(host, username, password);
SCPClient client = new SCPClient(conn);
client.put(localFile, remoteDir);
conn.close();
}
/**
* Run SSH command.
* @param host
* @param username
* @param password
* @param cmd
* @return exit status
* @throws IOException
*/
public static int runSSH(String host, String username, String password,
String cmd) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("running SSH cmd [" + cmd + "]");
}
Connection conn = getOpenedConnection(host, username, password);
Session sess = conn.openSession();
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
// attention: do not comment this block, or you will hit NullPointerException
// when you are trying to read exit status
String line = br.readLine();
if (line == null)
break;
if (logger.isDebugEnabled()) {
logger.debug(line);
}
}
sess.close();
conn.close();
return sess.getExitStatus().intValue();
}
/**
* return a opened Connection
* @param host
* @param username
* @param password
* @return
* @throws IOException
*/
private static Connection getOpenedConnection(String host, String username,
String password) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("connecting to " + host + " with user " + username
+ " and pwd " + password);
}
Connection conn = new Connection(host);
conn.connect(); // make sure the connection is opened
boolean isAuthenticated = conn.authenticateWithPassword(username,
password);
if (isAuthenticated == false)
throw new IOException("Authentication failed.");
return conn;
}
/**
* Run local command
* @param cmd
* @return exit status
* @throws IOException
*/
public static int runLocal(String cmd) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("running local cmd [" + cmd + "]");
}
Runtime rt = Runtime.getRuntime();
Process p = rt.exec(cmd);
InputStream stdout = new StreamGobbler(p.getInputStream());
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
String line = br.readLine();
if (line == null)
break;
if (logger.isDebugEnabled()) {
logger.debug(line);
}
}
return p.exitValue();
}
}
}
}
return p.exitValue();
}
}
2009-10-10 22:28
SSH命令使用手册
SSH 的详细使用方法如下：
ssh [-l login_name] [hostname | user@hostname] [command] ssh [-afgknqtvxCPX246] [-c blowfish | 3des] [-e escape_char] [-i identity_file] [-l login_name] [-o option] [-p port] [-L port:host:hostport] [-R port:host:hostport] [hostname | user@hostname] [command]
sshd
为执行 ssh 的 daemon，在读者使用 ssh 之前必须去激活 sshd，在此建议把它加在 /etc/init/rc.local 中，在每次开机时激活。
在执行 sshd 之前可以指定它的 port，例如：sshd –p 999
若有安装 SSL，可以指定 SSL 的 port 443，例如：sshd –p 443
这样就可以经过 SSL 及 SSH 双重的保护，但必须去指明使用的 port
ssh –l user –p 443 mouse.oit.edu.tw 才行，若不指明则仍然使用预设的port 22
ssh
选项：
-l login_name
指定登入于远程机器上的使用者，若没加这个选项，而直接打 ssh lost 也是可以的，它是以读者目前的使用者去做登入的动作。例如： ssh –l shie mouse.oit.edu.tw
-c blowfish|3des
在期间内选择所加密的密码型式。预设是3des，3des(作三次的资料加密) 是用三种不同的密码键作三次的加密-解密-加密。 blowfish 是一个快速区块密码编制器，它比3des更安全以及更快速。
-v
Verbose 模式。使ssh 去印出关于行程的除错讯息，这在连接除错，认 证和设定的问题上有很的帮助。
-V
显示版本。
-a
关闭认证代理联机。
-f
要求ssh 在背景执行命令，假如ssh要询问密码或通行证，但是使用者 想要它在幕后执行就可以用这个方式，最好还是加上-l user 例如在远程场所上激活 X11，有点像是 ssh –f host xterm 。
-e character
设定跳脱字符。
-g
允许远程主机去连接本地指派的 ports。
-i identity_file
选择所读取的 RSA 认证识别的档案。预设是在使用者的家目录 中的 .ssh/identity 。
-n
重导 stdin 到 /dev/null (实际上是避免读取 stdin)。必须当 ssh 在幕后执行时才使用。常见的招数是使用这选项在远程机器上去执行 X11 的程序 例如，ssh -n shadows.cs.hut.fi emacs &，将在 shadows.cs.hut.fi 上激活 emace，并且 X11 连接将自动地在加密的信道上发送。ssh 程序将把它放 在幕后。(假如ssh需要去询问密码时，这将不会动作)
-p port
连接远程机器上的 port。
-P
使用非特定的 port 去对外联机。如果读者的防火墙不淮许从特定的 port去联机时，就可以使用这个选项。注意这个选项会关掉 RhostsAuthentication 和 RhostsRSAAuthentication。
-q
安静模式。把所有的警告和讯息抑制，只有严重的错误才会被显示。
-t
强制配置 pseudo-tty。这可以在远程机器上去执行任意的 screen-based 程 式，例如操作 menu services。
-C
要求压缩所有资料(包含 stdin, stdout,stderr 和 X11 和 TCP/IP 连接) 压缩演算规则与 gzip 相同，但是压缩的等级不能控制。在调制解调器或 联机速度很慢的地方，压缩是个很好的选择，但如果读者的网络速路很 快的话，速度反而会慢下来。
-L listen-port:host:port
指派本地的 port 到达端机器地址上的 port。
-R listen-port:host:port
指派远程上的 port 到本地地址上的 port。
-2 强制 ssh 去使用协议版本 2。
-4 强制 ssh 去使用 IPv4 地址。
-6 强制 ssh 去使用 IPv6 地址。
scp
使用 scp 在远程机器上 copy 档案
例如：
copy 本地的档案到远程的机器上
scp /etc/lilo.conf k@net67.ee.oit.edu.tw:/home/k
会将本地的 /etc/lilo.conf 这个档案 copy 到 net67.ee.oit.edu.tw，使用者 k 的家目录下。
copy远程机器上的档案到本地来
scp k@net67.ee.oit.edu.tw:/etc/lilo.conf /etc
会将 net67.ee.oitdu.tw 中 /etc/lilo.conf 档案 copy 到本地的 /etc 目录下。
保持从来源 host 档案的属性
scp –p k@net67.ee.tw:/etc/lilo.conf /etc
在此必须注意使用者的权限是否可读取远程上的档案，若想知道更多关于 scp 的使用方法，可去看看 scp 的使用手册。
ssh-keygen
产生公开钥 (pulib key) 和私人钥 (private key)，以保障 ssh 联机的安性， 当 ssh 连 shd 服务器，会交换公开钥上，系统会检查 /etc/ssh_know_hosts 内储存的 key，如果找到客户端就用这个 key 产生一个随机产生的session key 传给服务器，两端都用这个 key 来继续完成 ssh 剩下来的阶段。
它会产生 identity.pub、identity 两个档案，私人钥存放于identity，公开钥存放于 identity.pub 中，接下来使用 scp 将 identity.pub copy 到远程机器的家目录下.ssh下的authorized_keys。 .ssh/authorized_keys(这个 authorized_keys 档案相当于协议的 rhosts 档案)，之后使用者能够不用密码去登入。RSA的认证绝对是比 rhosts 认证更来的安全可靠。
执行：
scp identity.pub k@linux1.ee.oit.edu.tw:.ssh/authorized_keys
若在使用 ssh-keygen 产生钥匙对时没有输入密码，则如上所示不需输入密码即可从 net67.ee.oit.edu.tw 去登入 linux1.ee.oit.edu.tw。在此，这里输入的密码可以跟帐号的密码不同，也可以不输入密码。
（2） JAVA与SSH的交互
由于在使用SSH命令时，中间要求输入用户密码，在设计JAVA程序时如果用Runtime的exec方法进行交互，经查证不可行。不过http://www.ganymed.ethz.ch/ssh2/提供了调用ssh和scp命令的jar，通过把用户名和密码传入api中就不需要用户介入输入密码。
从http://www.cjsdn.net/post/view?bid=6&id=173625&tpg=1&ppg=1&sty=1&age=0#173625得到一份示例代码如下：
package com.corp.prj.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.apache.log4j.Logger;
import ch.ethz.ssh2.Connection;
import ch.ethz.ssh2.SCPClient;
import ch.ethz.ssh2.Session;
import ch.ethz.ssh2.StreamGobbler;
/**
* Provides static methods for running SSH, scp as well as local commands.
*
*/
public class CommandRunner {
private static final Logger logger = Logger.getLogger(CommandRunner.class);
private CommandRunner() {
}
/**
* Get remote file through scp
* @param host
* @param username
* @param password
* @param remoteFile
* @param localDir
* @throws IOException
*/
public static void scpGet(String host, String username, String password,
String remoteFile, String localDir) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("spc [" + remoteFile + "] from " + host + " to " + localDir);
}
Connection conn = getOpenedConnection(host, username, password);
SCPClient client = new SCPClient(conn);
client.get(remoteFile, localDir);
conn.close();
}
/**
* Put local file to remote machine.
* @param host
* @param username
* @param password
* @param localFile
* @param remoteDir
* @throws IOException
*/
public static void scpPut(String host, String username, String password,
String localFile, String remoteDir) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("spc [" + localFile + "] to " + host + remoteDir);
}
Connection conn = getOpenedConnection(host, username, password);
SCPClient client = new SCPClient(conn);
client.put(localFile, remoteDir);
conn.close();
}
/**
* Run SSH command.
* @param host
* @param username
* @param password
* @param cmd
* @return exit status
* @throws IOException
*/
public static int runSSH(String host, String username, String password,
String cmd) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("running SSH cmd [" + cmd + "]");
}
Connection conn = getOpenedConnection(host, username, password);
Session sess = conn.openSession();
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
// attention: do not comment this block, or you will hit NullPointerException
// when you are trying to read exit status
String line = br.readLine();
if (line == null)
break;
if (logger.isDebugEnabled()) {
logger.debug(line);
}
}
sess.close();
conn.close();
return sess.getExitStatus().intValue();
}
/**
* return a opened Connection
* @param host
* @param username
* @param password
* @return
* @throws IOException
*/
private static Connection getOpenedConnection(String host, String username,
String password) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("connecting to " + host + " with user " + username
+ " and pwd " + password);
}
Connection conn = new Connection(host);
conn.connect(); // make sure the connection is opened
boolean isAuthenticated = conn.authenticateWithPassword(username,
password);
if (isAuthenticated == false)
throw new IOException("Authentication failed.");
return conn;
}
/**
* Run local command
* @param cmd
* @return exit status
* @throws IOException
*/
public static int runLocal(String cmd) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("running local cmd [" + cmd + "]");
}
Runtime rt = Runtime.getRuntime();
Process p = rt.exec(cmd);
InputStream stdout = new StreamGobbler(p.getInputStream());
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
String line = br.readLine();
if (line == null)
break;
if (logger.isDebugEnabled()) {
logger.debug(line); SSH命令使用手册
SSH 的详细使用方法如下：
ssh [-l login_name] [hostname | user@hostname] [command] ssh [-afgknqtvxCPX246] [-c blowfish | 3des] [-e escape_char] [-i identity_file] [-l login_name] [-o option] [-p port] [-L port:host:hostport] [-R port:host:hostport] [hostname | user@hostname] [command]
sshd
为执行 ssh 的 daemon，在读者使用 ssh 之前必须去激活 sshd，在此建议把它加在 /etc/init/rc.local 中，在每次开机时激活。
在执行 sshd 之前可以指定它的 port，例如：sshd –p 999
若有安装 SSL，可以指定 SSL 的 port 443，例如：sshd –p 443
这样就可以经过 SSL 及 SSH 双重的保护，但必须去指明使用的 port
ssh –l user –p 443 mouse.oit.edu.tw 才行，若不指明则仍然使用预设的port 22
ssh
选项：
-l login_name
指定登入于远程机器上的使用者，若没加这个选项，而直接打 ssh lost 也是可以的，它是以读者目前的使用者去做登入的动作。例如： ssh –l shie mouse.oit.edu.tw
-c blowfish|3des
在期间内选择所加密的密码型式。预设是3des，3des(作三次的资料加密) 是用三种不同的密码键作三次的加密-解密-加密。 blowfish 是一个快速区块密码编制器，它比3des更安全以及更快速。
-v
Verbose 模式。使ssh 去印出关于行程的除错讯息，这在连接除错，认 证和设定的问题上有很的帮助。
-V
显示版本。
-a
关闭认证代理联机。
-f
要求ssh 在背景执行命令，假如ssh要询问密码或通行证，但是使用者 想要它在幕后执行就可以用这个方式，最好还是加上-l user 例如在远程场所上激活 X11，有点像是 ssh –f host xterm 。
-e character
设定跳脱字符。
-g
允许远程主机去连接本地指派的 ports。
-i identity_file
选择所读取的 RSA 认证识别的档案。预设是在使用者的家目录 中的 .ssh/identity 。
-n
重导 stdin 到 /dev/null (实际上是避免读取 stdin)。必须当 ssh 在幕后执行时才使用。常见的招数是使用这选项在远程机器上去执行 X11 的程序 例如，ssh -n shadows.cs.hut.fi emacs &，将在 shadows.cs.hut.fi 上激活 emace，并且 X11 连接将自动地在加密的信道上发送。ssh 程序将把它放 在幕后。(假如ssh需要去询问密码时，这将不会动作)
-p port
连接远程机器上的 port。
-P
使用非特定的 port 去对外联机。如果读者的防火墙不淮许从特定的 port去联机时，就可以使用这个选项。注意这个选项会关掉 RhostsAuthentication 和 RhostsRSAAuthentication。
-q
安静模式。把所有的警告和讯息抑制，只有严重的错误才会被显示。
-t
强制配置 pseudo-tty。这可以在远程机器上去执行任意的 screen-based 程 式，例如操作 menu services。
-C
要求压缩所有资料(包含 stdin, stdout,stderr 和 X11 和 TCP/IP 连接) 压缩演算规则与 gzip 相同，但是压缩的等级不能控制。在调制解调器或 联机速度很慢的地方，压缩是个很好的选择，但如果读者的网络速路很 快的话，速度反而会慢下来。
-L listen-port:host:port
指派本地的 port 到达端机器地址上的 port。
-R listen-port:host:port
指派远程上的 port 到本地地址上的 port。
-2 强制 ssh 去使用协议版本 2。
-4 强制 ssh 去使用 IPv4 地址。
-6 强制 ssh 去使用 IPv6 地址。
scp
使用 scp 在远程机器上 copy 档案
例如：
copy 本地的档案到远程的机器上
scp /etc/lilo.conf k@net67.ee.oit.edu.tw:/home/k
会将本地的 /etc/lilo.conf 这个档案 copy 到 net67.ee.oit.edu.tw，使用者 k 的家目录下。
copy远程机器上的档案到本地来
scp k@net67.ee.oit.edu.tw:/etc/lilo.conf /etc
会将 net67.ee.oitdu.tw 中 /etc/lilo.conf 档案 copy 到本地的 /etc 目录下。
保持从来源 host 档案的属性
scp –p k@net67.ee.tw:/etc/lilo.conf /etc
在此必须注意使用者的权限是否可读取远程上的档案，若想知道更多关于 scp 的使用方法，可去看看 scp 的使用手册。
ssh-keygen
产生公开钥 (pulib key) 和私人钥 (private key)，以保障 ssh 联机的安性， 当 ssh 连 shd 服务器，会交换公开钥上，系统会检查 /etc/ssh_know_hosts 内储存的 key，如果找到客户端就用这个 key 产生一个随机产生的session key 传给服务器，两端都用这个 key 来继续完成 ssh 剩下来的阶段。
它会产生 identity.pub、identity 两个档案，私人钥存放于identity，公开钥存放于 identity.pub 中，接下来使用 scp 将 identity.pub copy 到远程机器的家目录下.ssh下的authorized_keys。 .ssh/authorized_keys(这个 authorized_keys 档案相当于协议的 rhosts 档案)，之后使用者能够不用密码去登入。RSA的认证绝对是比 rhosts 认证更来的安全可靠。
执行：
scp identity.pub k@linux1.ee.oit.edu.tw:.ssh/authorized_keys
若在使用 ssh-keygen 产生钥匙对时没有输入密码，则如上所示不需输入密码即可从 net67.ee.oit.edu.tw 去登入 linux1.ee.oit.edu.tw。在此，这里输入的密码可以跟帐号的密码不同，也可以不输入密码。
（2） JAVA与SSH的交互
由于在使用SSH命令时，中间要求输入用户密码，在设计JAVA程序时如果用Runtime的exec方法进行交互，经查证不可行。不过http://www.ganymed.ethz.ch/ssh2/提供了调用ssh和scp命令的jar，通过把用户名和密码传入api中就不需要用户介入输入密码。
从http://www.cjsdn.net/post/view?bid=6&id=173625&tpg=1&ppg=1&sty=1&age=0#173625得到一份示例代码如下：
package com.corp.prj.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.apache.log4j.Logger;
import ch.ethz.ssh2.Connection;
import ch.ethz.ssh2.SCPClient;
import ch.ethz.ssh2.Session;
import ch.ethz.ssh2.StreamGobbler;
/**
* Provides static methods for running SSH, scp as well as local commands.
*
*/
public class CommandRunner {
private static final Logger logger = Logger.getLogger(CommandRunner.class);
private CommandRunner() {
}
/**
* Get remote file through scp
* @param host
* @param username
* @param password
* @param remoteFile
* @param localDir
* @throws IOException
*/
public static void scpGet(String host, String username, String password,
String remoteFile, String localDir) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("spc [" + remoteFile + "] from " + host + " to " + localDir);
}
Connection conn = getOpenedConnection(host, username, password);
SCPClient client = new SCPClient(conn);
client.get(remoteFile, localDir);
conn.close();
}
/**
* Put local file to remote machine.
* @param host
* @param username
* @param password
* @param localFile
* @param remoteDir
* @throws IOException
*/
public static void scpPut(String host, String username, String password,
String localFile, String remoteDir) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("spc [" + localFile + "] to " + host + remoteDir);
}
Connection conn = getOpenedConnection(host, username, password);
SCPClient client = new SCPClient(conn);
client.put(localFile, remoteDir);
conn.close();
}
/**
* Run SSH command.
* @param host
* @param username
* @param password
* @param cmd
* @return exit status
* @throws IOException
*/
public static int runSSH(String host, String username, String password,
String cmd) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("running SSH cmd [" + cmd + "]");
}
Connection conn = getOpenedConnection(host, username, password);
Session sess = conn.openSession();
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
// attention: do not comment this block, or you will hit NullPointerException
// when you are trying to read exit status
String line = br.readLine();
if (line == null)
break;
if (logger.isDebugEnabled()) {
logger.debug(line);
}
}
sess.close();
conn.close();
return sess.getExitStatus().intValue();
}
/**
* return a opened Connection
* @param host
* @param username
* @param password
* @return
* @throws IOException
*/
private static Connection getOpenedConnection(String host, String username,
String password) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("connecting to " + host + " with user " + username
+ " and pwd " + password);
}
Connection conn = new Connection(host);
conn.connect(); // make sure the connection is opened
boolean isAuthenticated = conn.authenticateWithPassword(username,
password);
if (isAuthenticated == false)
throw new IOException("Authentication failed.");
return conn;
}
/**
* Run local command
* @param cmd
* @return exit status
* @throws IOException
*/
public static int runLocal(String cmd) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("running local cmd [" + cmd + "]");
}
Runtime rt = Runtime.getRuntime();
Process p = rt.exec(cmd);
InputStream stdout = new StreamGobbler(p.getInputStream());
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
String line = br.readLine();
if (line == null)
break;
if (logger.isDebugEnabled()) {
logger.debug(line);
}
}
return p.exitValue();
}
}
}
}
return p.exitValue();
}
}
分享到：
评论
1 楼
gmingsoft04
2012-04-08
重新排版了一下
package ssh;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.apache.log4j.Logger;
import ch.ethz.ssh2.Connection;
import ch.ethz.ssh2.SCPClient;
import ch.ethz.ssh2.Session;
import ch.ethz.ssh2.StreamGobbler;
/**
* Provides static methods for running SSH, scp as well as local commands.
*/
public class TestCmd {
private static final Logger logger = Logger.getLogger(CommandRunner.class);
private TestCmd() {
}
/**
* Get remote file through scp
* @param host
* @param username
* @param password
* @param remoteFile
* @param localDir
* @throws IOException
*/
public static void scpGet(String host, String username, String password,String remoteFile, String localDir) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("spc [" + remoteFile + "] from " + host + " to "+ localDir);
}
Connection conn = getOpenedConnection(host, username, password);
SCPClient client = new SCPClient(conn);
client.get(remoteFile, localDir);
conn.close();
}
/**
* Put local file to remote machine.
* @param host
* @param username
* @param password
* @param localFile
* @param remoteDir
* @throws IOException
*/
public static void scpPut(String host, String username, String password,String localFile, String remoteDir) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("spc [" + localFile + "] to " + host + remoteDir);
}
Connection conn = getOpenedConnection(host, username, password);
SCPClient client = new SCPClient(conn);
client.put(localFile, remoteDir);
conn.close();
}
/**
* Run SSH command.
* @param host
* @param username
* @param password
* @param cmd
* @return exit status
* @throws IOException
*/
public static int runSSH(String host, String username, String password,String cmd) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("running SSH cmd [" + cmd + "]");
}
Connection conn = getOpenedConnection(host, username, password);
Session sess = conn.openSession();
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
// attention: do not comment this block, or you will hit
// NullPointerException
// when you are trying to read exit status
String line = br.readLine();
if (line == null)
break;
if (logger.isDebugEnabled()) {
logger.debug(line);
}
}
sess.close();
conn.close();
return sess.getExitStatus().intValue();
}
/**
* return a opened Connection
* @param host
* @param username
* @param password
* @return
* @throws IOException
*/
private static Connection getOpenedConnection(String host, String username,String password) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("connecting to " + host + " with user " + username+ " and pwd " + password);
}
Connection conn = new Connection(host);
conn.connect(); // make sure the connection is opened
boolean isAuthenticated = conn.authenticateWithPassword(username,password);
if (isAuthenticated == false)
throw new IOException("Authentication failed.");
return conn;
}
/**
* Run local command
* @param cmd
* @return exit status
* @throws IOException
*/
public static int runLocal(String cmd) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("running local cmd [" + cmd + "]");
}
Runtime rt = Runtime.getRuntime();
Process p = rt.exec(cmd);
InputStream stdout = new StreamGobbler(p.getInputStream());
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
String line = br.readLine();
if (line == null)
break;
if (logger.isDebugEnabled()) {
logger.debug(line);
}
}
return p.exitValue();
}
}
发表评论
相关推荐
标题“Java Linux SSH登录”指的是使用Java编程语言与Linux操作系统进行安全外壳（SSH）通信的过程。在描述中提到，这个过程通常涉及建立一个通道并执行单个命令。这里，我们将会详细探讨Java如何通过SSH连接到Linux...
在IT行业中，Linux、Java、Web、SSH以及远程工具是至关重要的组成部分，它们构成了许多企业级应用的基础架构。下面将详细解析这些知识点及其相互关系。 首先，Linux是一种开源的操作系统，广泛应用于服务器环境，以...
在Java编程中，SSH（Secure Shell）是一种网络协议，用于在不安全的网络环境中提供安全的远程登录和其他服务。在本篇博客中，我们将探讨如何使用Java通过SSH远程执行Shell脚本，这对于系统管理和自动化任务非常有用...
Java SSH 执行命令主要涉及到Java编程语言与SSH（Secure Shell）协议的交互，通常用于远程服务器的管理和自动化任务执行。SSH是一种网络协议，允许用户安全地在不安全的网络上进行远程登录和其他网络服务。在Java中...
SSHXCUTE.jar是一个Java库，它允许程序员通过SSH连接到Linux系统并执行shell命令，而无需深入了解SSH的底层细节。 SSHXCUTE.jar的核心功能包括： 1. **建立SSH连接**：通过提供主机名、用户名、密码或密钥对信息，...
SSH（Secure Shell）是一种网络协议，用于在不安全的网络上安全地执行远程命令和传输数据。它通过加密技术保证了通信的安全性，防止了中间人攻击和其他形式的数据窃听。Java SSH实现允许开发者在Java环境中创建SSH...
在Java编程中，执行SSH（Secure Shell）命令是一项常见的任务，尤其在远程服务器管理、自动化运维和分布式系统中。SSH是一种网络协议，用于安全地在远程主机上执行命令和传输数据。下面我们将深入探讨如何在Java中...
Java中的JSCH库（JSch）是实现SSH连接的开源库，它提供了全面的功能，包括SFTP（SSH File Transfer Protocol）、SCP（Secure Copy）以及shell会话等。在本文中，我们将深入探讨如何使用JSch-0.1.54.jar这个库来实现...
Jsch（Java Secure Channel）是一个纯Java语言编写的库，它能够实现SSH（Secure Shell）功能。SSH是一种安全协议，它主要用于在不同的系统或服务器间建立安全的连接，并在传输数据的过程中对数据进行加密。在Java中...
jcraft源代码提供了一个纯Java实现的SSH连接解决方案，包括SFTP文件传输和执行远程shell命令的功能。对于需要在Java应用程序中与Linux服务器进行安全交互的开发者来说，这是一个宝贵的资源。通过对源代码的学习，...
SSH（Secure Shell）是一种网络协议，用于在不安全的网络上提供安全的远程登录和其他服务。在Java中实现SSH功能，通常会用到一些开源框架，如JSch、Apache MINA或者Apache SSHD等。这些框架允许开发者在Java应用程序...
SSH（Secure Shell）是一种网络协议，用于在不安全的网络上提供安全的远程登录和其他服务。在Java中，SSH常用于实现服务器之间的安全通信，比如文件传输、命令执行等。SSH框架主要有JSch和Apache SSHD。在这个"ssh....
在IT行业中，SSH（Secure Shell）是一种网络协议，用于安全地远程登录到服务器，执行命令以及传输文件。本文将深入探讨如何使用Java调用SSH命令，以便在开发过程中实现自动化运维或者远程操作。 首先，我们需要了解...
在Java编程中，有时我们需要与操作系统进行交互，执行系统级别的命令，例如在控制台执行CMD命令或者通过SSH连接远程Linux服务器执行shell命令。这在自动化脚本、系统管理或者远程监控等场景中非常常见。本篇文章将...
- **Java SSH 安全访问代码**：该标题表明了这段代码主要实现了通过 Java 进行 SSH 安全访问的功能。 #### 描述解读： - **Java SSH 安全访问代码**：这部分代码提供了 Java 实现 SSH 访问的基础结构。 - **里面有...
SSH（Secure Shell）是一种网络协议，用于在不安全的网络上提供安全的远程登录和其他服务。在Java中，SSH常用于构建基于SSH框架的Web应用，如Spring、Struts和Hibernate的组合，简称SSH框架。这个"ssh.zip"压缩包...
"基于Java实现ssh命令登录主机执行shell命令过程解析" 基于Java实现ssh命令登录主机执行shell命令过程解析是指使用Java语言实现ssh命令登录主机，并执行shell命令的过程。在这个过程中，我们将使用Java语言连接到...
Java 实现模拟 SSH 和 Telnet 登陆，以及发送与接收命令是网络编程中常见的需求，主要应用于自动化测试、远程系统管理或数据交换等场景。在本文中，我们将深入探讨如何利用 Java 实现这一功能。 首先，SSH（Secure ...
sshxcute 就是这样一个框架工具集，它基于 JSCH 构建，允许工程师利用Java 代码通过 SSH 连接远程批量执行 Linux/UNIX 系统上的命令或者脚本，同时加入了判断成功与否，取回输出等多种实用功能。sshxcute 不管是针对...
**Ganymed SSH-2 for Java** 是一个开源库，专为Java开发者设计，用于实现Secure Shell（SSH-2）协议。SSH-2是一种安全的网络协议，用于在网络之间提供加密通信，常用于远程登录、文件传输以及执行远程命令等。...