JSch：Java Secure Channel -- java 代码实现 ssh 远程操作

最新推荐文章于 2024-03-16 00:00:00 发布
最新推荐文章于 2024-03-16 00:00:00 发布
阅读量755 收藏 1
点赞数
分类专栏： Java 文章标签： JSch Java Secure Channel   java  代码实现  ssh远程操作  
原文链接：http://www.importnew.com/22322.html
版权

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到教程。

JSch 是SSH2的一个纯Java实现。

它允许你连接到一个 sshd 服务器，使用端口转发，X11转发，文件传输等等。

你可以将它的功能集成到你自己的程序中。

同时该项目也提供一个J2ME版本用来在手机上直连SSHD服务器。

 

 

官网:http://www.jcraft.com/jsch/中有很多例子http://www.jcraft.com/jsch/examples/

这里先采用（已做修改）其中2个来进行简单论述，希望对大家有所帮助。

本文采用的jsch版本是0.1.51. 

下载地址：http://sourceforge.net/projects/jsch/files/jsch/0.1.54/jsch-0.1.54.zip/download。

本文采用的Linux操作系统是CentOS6.5.

TIPS: 查看Linux操作系统（内核）版本可以使用：uname -a; uname -r; cat /etc/issue; cat /etc/redhat-release等命令。

 

 

第一个例子：采用Java模拟shell操作。
这里涉及到几个参数，会在下面的代码中有所体现：

  • USER：所连接的Linux主机登录时的用户名
  • PASSWORD：登录密码
  • HOST：主机地址
  • DEFAULT_SSH_PROT=端口号，默认为22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
package com.test.jsch;
 
/**
  * This program enables you to connect to sshd server and get the shell prompt.
  * You will be asked username, hostname and passwd.
  * If everything works fine, you will get the shell prompt. Output may
  * be ugly because of lacks of terminal-emulation, but you can issue commands.
  */
 
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.UserInfo;
import com.jcraft.jsch.Channel;
 
public class Shell{
     private static final String USER= "root" ;
     private static final String PASSWORD= "********" ;
     private static final String HOST= "localhost" ;
     private static final int DEFAULT_SSH_PORT= 22 ;
 
     public static void main(String[] arg){
 
         try {
             JSch jsch= new JSch();
             Session session = jsch.getSession(USER,HOST,DEFAULT_SSH_PORT);
             session.setPassword(PASSWORD);
 
             UserInfo userInfo = new UserInfo() {
                 @Override
                 public String getPassphrase() {
                     System.out.println( "getPassphrase" );
                     return null ;
                 }
                 @Override
                 public String getPassword() {
                     System.out.println( "getPassword" );
                     return null ;
                 }
                 @Override
                 public boolean promptPassword(String s) {
                     System.out.println( "promptPassword:" +s);
                     return false ;
                 }
                 @Override
                 public boolean promptPassphrase(String s) {
                     System.out.println( "promptPassphrase:" +s);
                     return false ;
                 }
                 @Override
                 public boolean promptYesNo(String s) {
                     System.out.println( "promptYesNo:" +s);
                     return true ; //notice here!
                 }
                 @Override
                 public void showMessage(String s) {
                     System.out.println( "showMessage:" +s);
                 }
             };
 
             session.setUserInfo(userInfo);
 
             // It must not be recommended, but if you want to skip host-key check,
             // invoke following,
             // session.setConfig("StrictHostKeyChecking", "no");
 
             //session.connect();
             session.connect( 30000 );   // making a connection with timeout.
 
             Channel channel=session.openChannel( "shell" );
 
             // Enable agent-forwarding.
             //((ChannelShell)channel).setAgentForwarding(true);
 
             channel.setInputStream(System.in);
       /*
       // a hack for MS-DOS prompt on Windows.
       channel.setInputStream(new FilterInputStream(System.in){
           public int read(byte[] b, int off, int len)throws IOException{
             return in.read(b, off, (len>1024?1024:len));
           }
         });
        */
 
             channel.setOutputStream(System.out);
 
       /*
       // Choose the pty-type "vt102".
       ((ChannelShell)channel).setPtyType("vt102");
       */
 
       /*
       // Set environment variable "LANG" as "ja_JP.eucJP".
       ((ChannelShell)channel).setEnv("LANG", "ja_JP.eucJP");
       */
 
             //channel.connect();
             channel.connect( 3 * 1000 );
         }
         catch (Exception e){
             System.out.println(e);
         }
     }
}

运行结果：

1
2
3
4
5
6
promptYesNo:
The authenticity of host '10.101.139.5' can't be established.
RSA key fingerprint is 59:0f:32:fc:7b:54:3d:90:c0:ef:5a:6b:fb:11:55:e1.
Are you sure you want to continue connecting?
trueLast login: Thu Sep 29 18:40:56 2016 from 10.101.48.240
[root@hidden ~] #

输入ls查看：

1
2
3
4
5
6
7
(省略一些....)
[root@hidden ~] # ls
ls
1.txt            install .log.syslog  vmware-tools-distrib  模板  文档  桌面
anaconda-ks.cfg  logs                workspace             视频  下载
install .log      util                公共的                图片  音乐
[root@hidden ~] #

这样就和在原linux系统中一样使用shell功能了。

如果需要跳过如下的检测：

1
2
3
The authenticity of host '10.101.139.5' can't be established.
RSA key fingerprint is 59:0f:32:fc:7b:54:3d:90:c0:ef:5a:6b:fb:11:55:e1.
Are you sure you want to continue connecting?

只需要在程序中加入相应的代码：

1
session.setConfig( "StrictHostKeyChecking" , "no" );

运行结果：

1
2
Last login: Thu Sep 29 18:39:18 2016 from 10.101.48.240
[root@hidden ~] #

第二个例子：运行一条shell指令，这里就那“ls”做例子好了。

No more talk, show you the code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
package com.test.jsch;
 
import com.jcraft.jsch.*;
import java.io.*;
 
public class Exec{
     private static final String USER= "root" ;
     private static final String PASSWORD= "********" ;
     private static final String HOST= "localhost" ;
     private static final int DEFAULT_SSH_PORT= 22 ;
 
     public static void main(String[] arg){
         try {
             JSch jsch= new JSch();
 
             Session session = jsch.getSession(USER,HOST,DEFAULT_SSH_PORT);
             session.setPassword(PASSWORD);
 
             // username and password will be given via UserInfo interface.
             session.setUserInfo( new MyUserInfo());
             session.connect();
 
             String command= "ls" ;
 
             Channel channel=session.openChannel( "exec" );
             ((ChannelExec)channel).setCommand(command);
 
             // X Forwarding
             // channel.setXForwarding(true);
 
             //channel.setInputStream(System.in);
             channel.setInputStream( null );
 
             //channel.setOutputStream(System.out);
 
             //FileOutputStream fos=new FileOutputStream("/tmp/stderr");
             //((ChannelExec)channel).setErrStream(fos);
             ((ChannelExec)channel).setErrStream(System.err);
 
             InputStream in=channel.getInputStream();
 
             channel.connect();
 
             byte [] tmp= new byte [ 1024 ];
             while ( true ){
                 while (in.available()> 0 ){
                     int i=in.read(tmp, 0 , 1024 );
                     if (i< 0 ) break ;
                     System.out.print( new String(tmp, 0 , i));
                 }
                 if (channel.isClosed()){
                     if (in.available()> 0 ) continue ;
                     System.out.println( "exit-status: " +channel.getExitStatus());
                     break ;
                 }
                 try {Thread.sleep( 1000 );} catch (Exception ee){}
             }
             channel.disconnect();
             session.disconnect();
         }
         catch (Exception e){
             System.out.println(e);
         }
     }
 
     private static class MyUserInfo implements UserInfo{
         @Override
         public String getPassphrase() {
             System.out.println( "getPassphrase" );
             return null ;
         }
         @Override
         public String getPassword() {
             System.out.println( "getPassword" );
             return null ;
         }
         @Override
         public boolean promptPassword(String s) {
             System.out.println( "promptPassword:" +s);
             return false ;
         }
         @Override
         public boolean promptPassphrase(String s) {
             System.out.println( "promptPassphrase:" +s);
             return false ;
         }
         @Override
         public boolean promptYesNo(String s) {
             System.out.println( "promptYesNo:" +s);
             return true ; //notice here!
         }
         @Override
         public void showMessage(String s) {
             System.out.println( "showMessage:" +s);
         }
     }
}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
promptYesNo:The authenticity of host '10.101.139.5' can't be established.
RSA key fingerprint is 59:0f:32:fc:7b:54:3d:90:c0:ef:5a:6b:fb:11:55:e1.
Are you sure you want to continue connecting?
1.txt
anaconda-ks.cfg
install .log
install .log.syslog
logs
util
vmware-tools-distrib
workspace
公共的
模板
视频
图片
文档
下载
音乐
桌面
exit -status: 0

第二个例子相比于第一个例子来说将UserInfo采用static class的方式提取出来，这样更直观一点。

JSch是以多线程方式一下，所以代码在connect后如果不disconnect channel和session,以及相关stream, 程序会一直等待，直到关闭。

需要注意的一个问题，相关的Stream和Channel是一定要关闭的，那么应该在什么时候来关？执行connect后，JSch接受客户端结果需要一定的时间（以秒计），如果马上关闭session就会发现什么都没接受到或内容不全。

还有一点注意，使用shell时，看到执行后没有结果，解决办法是在命令行后加上”\n”字符，server端就认为是一条完整的命令了。

最后将第一个和第二个例子合并，并提取一些公用模块，以便更好的理解和使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
package com.test.jsch;
 
import com.jcraft.jsch.*;
 
import java.io.*;
import java.util.concurrent.TimeUnit;
 
import static java.lang.String.format;
 
/**
  * Created by hidden on 2016/9/29.
  */
public class SSHExecutor {
     private static long INTERVAL = 100L;
     private static int SESSION_TIMEOUT = 30000 ;
     private static int CHANNEL_TIMEOUT = 3000 ;
     private JSch jsch = null ;
     private Session session = null ;
 
     private SSHExecutor(SSHInfo sshInfo) throws JSchException {
         jsch = new JSch();
         session = jsch.getSession(sshInfo.getUser(),sshInfo.getHost(),sshInfo.getPort());
         session.setPassword(sshInfo.getPassword());
         session.setUserInfo( new MyUserInfo());
         session.connect(SESSION_TIMEOUT);
     }
 
     /*
     * 在这里修改访问入口,当然可以把这个方法弄到SSHExecutor外面，这里是方便操作才这么做的
     * */
     public static SSHExecutor newInstance() throws JSchException {
         SSHInfo sshInfo = new SSHInfo("root","******","locahost",22);
         return new SSHExecutor(sshInfo);
     }
 
     /*
     * 注意编码转换
     * */
     public long shell(String cmd, String outputFileName) throws JSchException, IOException, InterruptedException {
         long start = System.currentTimeMillis();
         Channel channel = session.openChannel("shell");
         PipedInputStream pipeIn = new PipedInputStream();
         PipedOutputStream pipeOut = new PipedOutputStream( pipeIn );
         FileOutputStream fileOut = new FileOutputStream( outputFileName, true);
         channel.setInputStream(pipeIn);
         channel.setOutputStream(fileOut);
         channel.connect(CHANNEL_TIMEOUT);
 
         pipeOut.write(cmd.getBytes());
         Thread.sleep( INTERVAL );
         pipeOut.close();
         pipeIn.close();
         fileOut.close();
         channel.disconnect();
         return System.currentTimeMillis() - start;
     }
 
     public int exec(String cmd) throws IOException, JSchException, InterruptedException {
         ChannelExec channelExec = (ChannelExec)session.openChannel( "exec" );
         channelExec.setCommand( cmd );
         channelExec.setInputStream( null );
         channelExec.setErrStream( System.err );
         InputStream in = channelExec.getInputStream();
         channelExec.connect();
 
         int res = -1;
         StringBuffer buf = new StringBuffer( 1024 );
         byte[] tmp = new byte[ 1024 ];
         while ( true ) {
             while ( in.available() > 0 ) {
                 int i = in.read( tmp, 0, 1024 );
                 if ( i < 0 ) break;
                 buf.append( new String( tmp, 0, i ) );
             }
             if ( channelExec.isClosed() ) {
                 res = channelExec.getExitStatus();
                 System.out.println( format( "Exit-status: %d", res ) );
                 break;
             }
             TimeUnit.MILLISECONDS.sleep(100);
         }
         System.out.println( buf.toString() );
         channelExec.disconnect();
         return res;
     }
 
     public Session getSession(){
         return session;
     }
 
     public void close(){
         getSession().disconnect();
     }
 
     /*
     * SSH连接信息
     * */
     public static class SSHInfo{
         private String user;
         private String password;
         private String host;
         private int port;
 
         public SSHInfo(String user, String password, String host, int port) {
             this.user = user;
             this.password = password;
             this.host = host;
             this.port = port;
         }
 
         public String getUser() {
             return user;
         }
 
         public String getPassword() {
             return password;
         }
 
         public String getHost() {
             return host;
         }
 
         public int getPort() {
             return port;
         }
     }
 
     /*
     * 自定义UserInfo
     * */
     private static class MyUserInfo implements UserInfo{
 
         @Override public String getPassphrase() { return null ; }
 
         @Override public String getPassword() { return null ; }
 
         @Override public boolean promptPassword(String s) { return false ; }
 
         @Override public boolean promptPassphrase(String s) { return false ; }
 
         @Override
         public boolean promptYesNo(String s) {
             System.out.println(s);
             System.out.println( "true" );
             return true ;
         }
 
         @Override public void showMessage(String s) { }
     }
}

测试代码：

1
2
3
4
5
6
7
8
9
SSHExecutor ssh =  SSHExecutor.newInstance();
System.out.println( "================" );
long shell1 = ssh.shell( "ls\n" , "C:\\Users\\hidden\\Desktop\\shell.txt" );
long shell2 = ssh.shell( "pwd\n" , "C:\\Users\\hidden\\Desktop\\shell.txt" );
System.out.println( "shell 1 执行了" +shell1+ "ms" );
System.out.println( "shell 2 执行了" +shell2+ "ms" );
System.out.println( "================" );
int cmd1 = ssh.exec( "ls\n" );
ssh.close();

测试结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
The authenticity of host '10.101.139.5' can't be established.
RSA key fingerprint is 59:0f:32:fc:7b:54:3d:90:c0:ef:5a:6b:fb:11:55:e1.
Are you sure you want to continue connecting?
true
================
shell 1 执行了142ms
shell 2 执行了132ms
================
Exit-status: 0
1.txt
anaconda-ks.cfg
install .log
install .log.syslog
logs
util
vmware-tools-distrib
workspace
公共的
模板
视频
图片
文档
下载
音乐
桌面

还有解释查看一下左边是否有个shell.txt以及shell.txt是否有相应的内容。

 

 

转自：http://www.importnew.com/22322.html

微风--轻许--
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
secure-channel-srp6a-applet:用于SRP-6a的经过密码验证的安全通道的Java卡小程序，可保护元素智能卡
05-07
SRP-6a Java卡小程序 此Java Card小程序是Wu [1]对安全远程密码（SRP-6a）密码认证的安全通道协议的实现。 结合使用现成的应用程序（例如使用我们的的Android应用程序）的实现，您可以建立一个使用PIN或密码进行相互身份验证的安全通信通道。 此实现依赖于标准Java Card 2.2 API功能。 尽管Java Card 2.2 API的安全元素通常配备有必要的硬件，以计算SRP中使用的模运算，但是标准Java Card 2.2 API的局限性阻止了对必需密码原语的直接访问。 因此，这给以可接受的性能实施SRP带来了挑战。 但是，通过利用该平台提供的RSA加密API，我们表明可以在密码协处理器的支持下计算乘幂和乘法。 这以及对该协议的少量修改，使得可以在Java卡小程序中以合理的计算时间实现SRP-6a服务器端。 我们在MoMM2014论文[2]中对此进行了介绍
JSch -- Java Secure Channel
amu0324的专栏
06-14 2945
 JSch 是SSH2的一个纯Java实现。它允许你连接到一个sshd 服务器，使用端口转发，X11转发，文件传输等等。你可以将它的功能集成到你自己的 程序中。此外，JSch依赖JavaTM Cryptography Extension (JCE) 。     JSch主页http://www.jcraft.com/jsch/      其实，熟悉ant或多或少会知道。ant的ta
jsch(Java Secure Channel)
xujian161的专栏
06-19 193
    JSch 是SSH2的一个纯Java实现。它允许你连接到一个sshd 服务器，使用端口转发，X11转发，文件传输等等。你可以将它的功能集成到你自己的 程序中。此外，JSch依赖JavaTM Cryptography Extension (JCE) 。       JSch主页http://www.jcraft.com/jsch/       其实，熟悉ant或多或少会知道。ant的ta...
JSch - Java Secure Channel : java 代码实现服务器远程操作
愿我如星君如月 ... 夜夜流光相皎洁 ...
05-23 791
一、前言JSch是SSH2的纯Java实现。JSch允许您连接到sshd服务器并使用端口转发，X11转发，文件传输等，您可以将其功能集成到您自己的Java程序中。JSch获得BSD格式许可证。最初，我们开发这些东西的动机是允许我们的纯Java X服务器WiredX的用户享受安全的X会话。所以，我们的努力主要是为了实现用于X11转发的SSH2协议。当然，我们现在也有兴趣添加端口转发，文件传输，终...
java中JSch，ChannelSftp，Session，SFTP
java 开发
09-06 2466
Session是会话，比如打电话，从拨号到挂断这就是一个Session；Channel是通道,我的理解是比如打电话时，Channel表示是使用联通信号或者是移动信号或者是电信信号。 JSch是Java Secure Channel的缩写 JSch是一个SSH2的纯Java实现。它允许你连接到一个SSH服务器，并且可以使用端口转发，X11转发，文件传输等，当然你也可以集成它的功能到你自己的应用程序。 SFTP是Secure File Transfer Protocol的缩写，安全文件传送协议。可以为传输文件提
java进行ssh协议连接的jar包jsch-0.1.54.jar
12-14
Java中的JSCH库（JSch）是实现SSH连接的开源库，它提供了全面的功能，包括SFTP（SSH File Transfer Protocol）、SCP（Secure Copy）以及shell会话等。在本文中，我们将深入探讨如何使用JSch-0.1.54.jar这个库来实现...
ExampleConnectionSSH:使用 Java 和 jsch lib 的 SSH 连接示例
07-12
JSch是Java的一个开源库，它实现了SSH2协议，允许开发者在Java应用中进行SSH连接，执行远程命令，以及实现SFTP文件传输。 SSH连接的核心概念包括身份验证、加密通信和端口转发。身份验证通常基于公钥/私钥对或密码...
java使用JSCH实现SFTP文件管理
10-16
JSCH（Java Secure Channel）是一个纯Java实现的SSH2库，允许用户通过SSH协议连接到远程系统并执行各种操作，包括SFTP（Secure File Transfer Protocol）。 首先，为了使用JSCH进行SFTP操作，我们需要在项目中引入...
java使用JSCH进行连接远程服务器Demo
10-31
Java使用JSCH（Java Secure Channel）库连接远程服务器是一个常见的任务，特别是在自动化运维、文件传输或者执行远程命令等场景中。JSCH是一个纯Java实现的SSH2库，它提供了连接到支持SSH协议的服务器的能力，如...
java项目调用ssh实现cli命令
04-15
接下来，我们来看如何在Java代码中使用JSch库来实现SSH命令的执行。以下是一个简单的示例： ```java import com.jcraft.jsch.Channel; import com.jcraft.jsch.ChannelExec; import com.jcraft.jsch.JSch; import ...
jsch的Channel基础知识记录
qq_45863248的博客
07-08 3708
JSCH Channel 常用方法： ​ void connect():打开通道，不设置超时时间 ​ void connect(int connectTimeout) 设置超时时间 ​ void disconnect() 断开通道 ​ int getExitStatus():检索通道对应远程命令的退出状态 ​ int getId():获取会话的通道标识 ​ InputStream getInputStream():获取此通道的InputStream ​ OutputStream
jsch channel.java 292_java - 为什么JSch ChannelSftp返回“句柄关闭”？ - 堆栈内存溢出...
weixin_29608135的博客
02-27 352
我正在使用jsch 0.1.54，并且正在尝试通过SFTP访问FTP服务器。 一切正常，我可以转到所需的目录，但是当我使用执行channel.ls(“ *”);的模式获取文件时； 我只有第一个匹配项，而下一个匹配项是“句柄关闭 ”，但没有文件名。 为什么？更确切地说，当我最终到达所需目录时，sftp.ls(ftpAccount + File.separator + lsEntry.getFi...
JSch线上出现com.jcraft.jsch.JSchException: channel is not opened.问题分析
qq_43392759的博客
11-29 1359
在SSH协议的会话（session）中，channel是一个用于在客户端和服务器之间建立通信通道的概念。Channel的主要目的是在SSH连接中提供一种安全、加密和可靠的数据传输机制。通道的创建：当一个SSH会话建立时，可以创建多个channel。Channel是逻辑上的概念，用于在客户端和服务器之间传输数据。因为出现比较少,初步觉得是网络波动导致,但是在系统繁忙的时候频繁出现,此处写了个demo具体分析一下。追踪channel的创建过程,确实是这样,框架中也是这样保存的。关于channel,首先要了解。
JSch基本使用
weixin_34248705的博客
09-29 600
JSch 是SSH2的一个纯Java实现。它允许你连接到一个sshd 服务器，使用端口转发，X11转发，文件传输等等。你可以将它的功能集成到你自己的 程序中。同时该项目也提供一个J2ME版本用来在手机上直连SSHD服务器。 官网:http://www.jcraft.com/jsch/中有很多例子http://www.jcraft.co...
Jsch实践(四)：Jsch的ChannelExec类和ChannelShell类有什么区别？各有什么特点和缺点？如何准确的理解他们以及他们的使用场景是什么？
最新发布
weixin_43860634的博客
03-16 910
Jsch实践(四)：Jsch的ChannelExec类和ChannelShell类有什么区别？各有什么特点和缺点？如何准确的理解他们以及他们的使用场景是什么？
java linux ssh连接_Java代码实现ssh连接Linux
weixin_33983809的博客
02-12 394
import java.util.Arrays;import java.util.HashMap;import java.util.Map;import org.apache.sshd.client.SshClient;import org.apache.sshd.client.channel.ChannelShell;import org.apache.sshd.client.channel.C...
Java使用jsch远程下载文件
没鞋的脚的博客
06-13 799
Channel）是一个ssh2的java实现，允许连接到一个ssh服务器（即典型的xshell连接方式），并且可以使用端口转发，文件传输等。SFTP(Secure File Transfer Protocol)安全文件传送协议，可以为传输文件提供一种安全的加密方法。SSH的一部份，是一种传输文件到服务器的安全方式，但是传输效率比普通的FTP要低。
JSch库入门实战应用，推荐大家学习
自强不息，厚德载物，未来可期
06-30 717
JSch是一个用于在Java平台上实现SSH连接的库。它提供了一个Java实现的SSH2协议客户端，可以用于在Java应用程序中进行SSH连接、文件传输和远程命令执行等操作。 JSch库提供了以下关键功能： 1. SSH连接：JSch允许建立到SSH服务器的安全连接。它支持密码认证、公钥认证和密钥交换等多种身份验证方法。 2. 文件传输：JSch可以执行SCP(Secure Copy)和SFTP...
java channelexec_关于Java：如何使用JSch ChannelExec捕获远程输入
weixin_39708737的博客
02-23 1010
我编写了一个程序，该程序仅在远程计算机上运行命令，然后停止。 有一个程序：import com.jcraft.jsch.*;import java.io.*;public class JSchTest {private static String readString(String prompt) {if (prompt != null) {System.out.println(prompt);}...
jsch-0.1.55-API
05-12
JSch是Java Secure Channel的缩写，它是一个纯Java实现的SSH2协议客户端。JSch提供了一个易于使用的API来实现SSH连接和文件传输，它可以用于构建SSH客户端，以便可以通过SSH协议执行各种远程操作。 JSch API包含了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值