Cyberduck Mountain Duck CLI

Ticket #75: ,ssh-agent.1.diff

File ,ssh-agent.1.diff, 176.4 KB (added by asf@…, on Sep 25, 2006 at 8:51:38 PM)

sshtools.com agent code integration, jbus integration, agent use and fallback in SFTP connections

  • build.xml

     
    271271                        manifest="${build}/MANIFEST.MF">
    272272                        <fileset dir="${build.classes}">
    273273                                <include name="com/sshtools/**/*.class"/>
     274                                <include name="com/echogent/**/*.class"/>
    274275                        </fileset>
    275276                </jar>
    276277                <jar jarfile="${build}/ftp.jar"
  • source/ch/cyberduck/core/sftp/SFTPSession.java

     
    2121import com.sshtools.j2ssh.SshClient;
    2222import com.sshtools.j2ssh.SshEventAdapter;
    2323import com.sshtools.j2ssh.SshException;
     24import com.sshtools.j2ssh.agent.*;
    2425import com.sshtools.j2ssh.authentication.*;
    2526import com.sshtools.j2ssh.configuration.SshConnectionProperties;
    2627import com.sshtools.j2ssh.connection.Channel;
     
    3940
    4041import org.apache.log4j.Logger;
    4142
     43import java.io.*;
    4244import java.io.IOException;
    4345
    4446/**
     
    275277        // Try the authentication
    276278        return SSH.authenticate(pk);
    277279    }
     280       
     281        private int loginUsingSshAgent(Login credentials) throws IOException, SshException {
     282                log.info("Trying SSH agent authentication...");
     283                AgentAuthenticationClient ag = new AgentAuthenticationClient();
     284                ag.setUsername(credentials.getUsername());
     285                // find out the agent socket. XXX: this is horrible. 1.4 doesn't have System.getenv )-:
     286                Runtime rt = Runtime.getRuntime();
     287                Process p = rt.exec(new String[]{"/bin/sh", "-c", "echo $SSH_AUTH_SOCK"});
     288                String sockname = (new BufferedReader(new InputStreamReader(p.getInputStream()))).readLine().trim();
     289                try {
     290                        ag.setAgent(SshAgentClient.connectLocalAgent("cyberduck", sockname));
     291                        return SSH.authenticate(ag);
     292                } catch (AgentNotAvailableException e) {
     293                        log.fatal("Agent not available", e);
     294                        return AuthenticationProtocolState.FAILED;
     295                }
     296        }
    278297
    279298    protected void login() throws IOException, SshException, ConnectionCanceledException, LoginCanceledException {
    280299        if(null == SSH) {
     
    285304        }
    286305        this.message(NSBundle.localizedString("Authenticating as", "Status", "") + " '"
    287306                + host.getCredentials().getUsername() + "'");
     307                if (AuthenticationProtocolState.COMPLETE == this.loginUsingSshAgent(host.getCredentials())) {
     308                        this.message(NSBundle.localizedString("Login successful", "Credentials", ""));
     309                        return;
     310                }
    288311        if(host.getCredentials().usesPublicKeyAuthentication()) {
    289312            if(AuthenticationProtocolState.COMPLETE == this.loginUsingPublicKeyAuthentication(host.getCredentials()))
    290313            {
  • source/com/echogent/jbuds/UnixDomainSocket.java

     
     1/*
     2************************************************************************
     3* @(#)UnixDomainSocket.java
     4* Copyright (c) 2001
     5* Echogent Systems, Inc. a California Corporation
     6************************************************************************
     7* J-BUDS version 1.0
     8* A Java-based Unix Domain Socket library
     9*
     10* This library is free software; you can redistribute it and/or
     11* modify it under the terms of version 2.1 of the GNU Lesser General
     12* Public License as published by the Free Software Foundation.
     13*
     14* This library is distributed in the hope that it will be useful,
     15* but WITHOUT ANY WARRANTY; without even the implied warranty of
     16* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     17* Lesser General Public License for more details:
     18*
     19* http://www.opensource.org/licenses/lgpl-license.html
     20* http://www.gnu.org/copyleft/lesser.html
     21*
     22* To obtain a written copy of the GNU Lesser General Public License,
     23* please write to the Free Software Foundation, Inc., 59 Temple Place,
     24* Suite 330, Boston, MA  02111-1307 USA
     25*
     26*/
     27
     28// This package
     29package com.echogent.jbuds;
     30
     31// Dependencies
     32import java.io.IOException;
     33import java.io.InputStream;
     34import java.io.InterruptedIOException;
     35import java.io.OutputStream;
     36
     37import com.apple.cocoa.foundation.NSBundle;
     38
     39import org.apache.log4j.Logger;
     40
     41/*
     42************************************************************************
     43* Class: UnixDomainSocket
     44************************************************************************
     45*/ /**
     46* This class provides a means of connecting to a unix domain socket server.
     47*
     48* @version 1.0
     49* @author Robert Morgan
     50*/
     51public class UnixDomainSocket
     52{
     53        private static Logger log = Logger.getLogger(UnixDomainSocket.class);
     54        static
     55        {
     56        // Ensure native unix domain sockets library is loaded
     57        try {
     58            NSBundle bundle = NSBundle.mainBundle();
     59            String lib = bundle.resourcePath() + "/Java/" + "libUnixDomainSockets.dylib";
     60            log.info("Locating libUnixDomainSockets.dylib at '" + lib + "'");
     61            System.load(lib);
     62            log.info("libUnixDomainSockets.dylib loaded");
     63        }
     64        catch (UnsatisfiedLinkError e) {
     65            log.error("Could not load the libUnixDomainSockets.dylib library:" + e.getMessage());
     66        }
     67        }
     68       
     69        // Input and output streams
     70        private UnixDomainSocketInputStream moIn;
     71        private UnixDomainSocketOutputStream moOut;
     72
     73        // Socket read timeout
     74        private int miTimeout;
     75       
     76        // Native methods, implemented in the Unix Domain Socket C library
     77        private native static int nativeOpen(String socketFile);
     78        private native static int nativeRead(int nativeSocketFileHandle);
     79        private native static int nativeWrite(int nativeSocketFileHandle, int data);
     80        private native static void nativeClose(int nativeSocketFileHandle);
     81        private native static void nativeCloseInput(int nativeSocketFileHandle);
     82        private native static void nativeCloseOutput(int nativeSocketFileHandle);
     83       
     84        // Handle for the native Unix Domain Socket
     85        private int miNativeSocketFileHandle;
     86       
     87    /*
     88    ********************************************************************
     89    * UnixDomainSocket()
     90    ********************************************************************
     91    */ /**
     92    * Creates a unix domain socket and connects it to the server
     93    * specified by the socket file.
     94    *
     95    * @param socketFile Name of the socket file
     96    *
     97    * @throws IOException If unable to construct the socket
     98    *
     99    */
     100        public UnixDomainSocket(String sSocketFile)
     101      throws IOException
     102        {
     103                // Create the native socket, and connect using the specified socket file
     104                if( (miNativeSocketFileHandle = nativeOpen(sSocketFile)) < 0)
     105                {
     106                        throw new IOException("Unable to upen Unix Domain Socket");
     107                }
     108               
     109                // Initialise the socket input and output streams
     110                moIn = new UnixDomainSocketInputStream();
     111                moOut = new UnixDomainSocketOutputStream();
     112
     113    } // UnixDomainSocket()
     114       
     115    /*
     116    ********************************************************************
     117    * getInputStream()
     118    ********************************************************************
     119    */ /**
     120    * Returns an input stream for this socket.
     121    *
     122    * @return An input stream for reading bytes from this socket
     123    *
     124    */
     125    public InputStream getInputStream()
     126    {
     127        return (InputStream)moIn;
     128
     129    } // getInputStream()
     130       
     131    /*
     132    ********************************************************************
     133    * getOutputStream()
     134    ********************************************************************
     135    */ /**
     136    * Returns an output stream for this socket.
     137    *
     138    * @return An output stream for writing bytes to this socket
     139    *
     140    */
     141    public OutputStream getOutputStream()
     142    {
     143        return (OutputStream)moOut;
     144
     145    } // getOutputStream()
     146
     147    /*
     148    ********************************************************************
     149    * setTimeout()
     150    ********************************************************************
     151    */ /**
     152    * Sets the read timeout for the socket. If a read call blocks for
     153    * the specified amount of time it will be cancelled, and a
     154    * java.io.InterruptedIOException will be thrown. A timeout of zero
     155    * is interpreted as an infinite timeout.
     156    *
     157    * @param iTimeout The specified timeout, in milliseconds.
     158    *
     159    */
     160    public void setTimeout(int iTimeout)
     161    {
     162        miTimeout = iTimeout;
     163
     164    } // setTimeout()
     165       
     166    /*
     167    ********************************************************************
     168    * close()
     169    ********************************************************************
     170    */ /**
     171    * Closes the socket.
     172    *
     173    */
     174    public void close()
     175    {
     176        nativeClose(miNativeSocketFileHandle);
     177
     178    } // close()
     179       
     180    /*
     181    ************************************************************************
     182    * Class: UnixDomainSocketInputStream
     183    ************************************************************************
     184    */ /**
     185    * Local private wrapper class for the native input stream.
     186    *
     187    */
     188        private class UnixDomainSocketInputStream extends InputStream
     189        {
     190                // Reads a byte of data from the socket input stream
     191                public int read() throws IOException
     192                {
     193                        int miData;
     194                       
     195                        // If a timeout is set, then use a read thread
     196                        if (miTimeout>0)
     197                        {
     198                                // Create a thread to read the byte
     199                                UnixDomainSocketReadThread oThread =
     200                  new UnixDomainSocketReadThread();
     201                                oThread.setDaemon(true);
     202                                oThread.start();
     203                               
     204                                try
     205                                {
     206                                        // Wait until the specified timeout for thread to complete
     207                                        oThread.join(miTimeout);
     208                                }
     209                                catch (InterruptedException e)
     210                                {
     211                }
     212
     213                                // If the thread is still alive, then the read() call has
     214                // blocked longer than the specified timeout, so stop thread
     215                                if (oThread.isAlive())
     216                                {
     217                                        oThread.stop();
     218                                        throw new InterruptedIOException(
     219                      "Unix Domain Socket read() call timed out");
     220                                }
     221                                else
     222                                {
     223                                        miData = oThread.getData();
     224                                }
     225                        }
     226                        else
     227                        {
     228                                miData = nativeRead(miNativeSocketFileHandle);
     229                        }
     230
     231                        return miData;
     232                       
     233                } // read()
     234               
     235                // Closes the socket input stream
     236                public void close() throws IOException
     237                {
     238                        nativeCloseInput(miNativeSocketFileHandle);
     239
     240                } // close()
     241
     242        } // Class: UnixDomainSocketInputStream
     243       
     244    /*
     245    ************************************************************************
     246    * Class: UnixDomainSocketOutputStream
     247    ************************************************************************
     248    */ /**
     249    * Local private wrapper class for the native output stream.
     250    *
     251    */
     252        private class UnixDomainSocketOutputStream extends OutputStream
     253        {
     254                // Write a byte of data to the socket output stream
     255                public void write(int iData) throws IOException
     256                {               
     257                        if ((nativeWrite(miNativeSocketFileHandle, iData))<0)
     258                        {
     259                                throw new IOException("Unable to write to Unix Domain Socket");                                                                         
     260                        }
     261
     262                } // write()
     263                       
     264                // Closes the socket output stream
     265                public void close() throws IOException
     266                {
     267                        nativeCloseOutput(miNativeSocketFileHandle);
     268
     269                } // close()
     270
     271        } // Class: UnixDomainSocketOutputStream
     272
     273    /*
     274    ************************************************************************
     275    * Class: UnixDomainSocketReadThread
     276    ************************************************************************
     277    */ /**
     278    * Thread class reads a byte of data from the socket. Used for enforcing
     279    * timeouts.
     280    *
     281    */
     282        private class UnixDomainSocketReadThread extends Thread
     283        {
     284                private int miData;
     285
     286                public void run()
     287                {
     288                        miData = nativeRead(miNativeSocketFileHandle);
     289
     290                } // run()     
     291
     292                public int getData()
     293                {
     294                        return miData;
     295
     296                } // getData()
     297
     298        } // Class: UnixDomainSocketReadThread
     299
     300} // Class: UnixDomainSocket
  • source/com/echogent/jbuds/UnixDomainSocket.c

     
     1// UnixDomainSocket.c
     2// J-BUDS version 1.0
     3// Copyright (c) 2001; Echogent Systems, Inc.
     4// See COPYRIGHT file for license details
     5
     6#include <jni.h>
     7// #include "com_echogent_jbuds_UnixDomainSocket.h" // XXX: this file isn't present in the original distribution either?
     8
     9#include <string.h>
     10#include <errno.h>
     11#include <sys/socket.h>
     12#include <sys/types.h>
     13#include <sys/un.h>
     14#include <sys/unistd.h>
     15#include <stdio.h>
     16
     17JNIEXPORT jint JNICALL Java_com_echogent_jbuds_UnixDomainSocket_nativeOpen(JNIEnv *jEnv, jclass jClass, jstring jSocketFile)
     18{
     19        struct sockaddr_un serverAddress;
     20        int socketFileHandle;
     21       
     22        // Convert the Java socket file String to a C string
     23        const char *socketFile = (*jEnv)->GetStringUTFChars(jEnv, jSocketFile, 0);
     24       
     25        // Create the server address
     26        bzero((char *)&serverAddress,sizeof(serverAddress));
     27        serverAddress.sun_family = AF_UNIX;
     28        strcpy(serverAddress.sun_path, socketFile);
     29
     30        // Create the socket
     31        if( (socketFileHandle = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
     32        {
     33                // Return error
     34                return -1;
     35        }
     36
     37        if(connect(socketFileHandle, (struct sockaddr *)&serverAddress, sizeof(serverAddress)) <0)
     38        {
     39                // Return error
     40                return -1;
     41        }
     42       
     43        // Release the C socket file string
     44        (*jEnv)->ReleaseStringUTFChars(jEnv, jSocketFile, socketFile);
     45       
     46        // Return the socket file handle
     47        return socketFileHandle;
     48}
     49
     50JNIEXPORT jint JNICALL Java_com_echogent_jbuds_UnixDomainSocket_nativeRead(JNIEnv *jEnv, jclass jClass, jint jSocketFileHandle)
     51{
     52        // Create the char buffer
     53        char buffer[1];
     54       
     55        // Read a byte from the socket into the buffer
     56        int result = read(jSocketFileHandle, buffer, 1);
     57       
     58        // If the result is less than 0, return the error
     59        if(result<0)
     60        {
     61                return result;
     62        }
     63        else if (result == 0)
     64        {
     65            return -1;
     66        }
     67        // Otherwise, return the data read
     68        else
     69        {       
     70        return buffer[0];
     71        }
     72
     73}
     74
     75JNIEXPORT jint JNICALL Java_com_echogent_jbuds_UnixDomainSocket_nativeWrite(JNIEnv *jEnv, jclass jClass, jint jSocketFileHandle, jint jData)
     76{
     77        // Create the char buffer and put the data in it
     78        char buffer[] = {jData};
     79
     80        // Write a byte from the buffer to the socket
     81        int result = write(jSocketFileHandle, buffer, 1);
     82
     83        // Return the result
     84        return result;
     85}
     86
     87JNIEXPORT void JNICALL Java_com_echogent_jbuds_UnixDomainSocket_nativeClose(JNIEnv *jEnv, jclass jClass, jint jSocketFileHandle)
     88{
     89        // Close the socket
     90        shutdown(jSocketFileHandle, SHUT_RDWR);
     91}
     92
     93JNIEXPORT void JNICALL Java_com_echogent_jbuds_UnixDomainSocket_nativeCloseInput(JNIEnv *jEnv, jclass jClass, jint jSocketFileHandle)
     94{
     95        // Close the socket input stream
     96        shutdown(jSocketFileHandle, SHUT_RD);
     97}
     98
     99JNIEXPORT void JNICALL Java_com_echogent_jbuds_UnixDomainSocket_nativeCloseOutput(JNIEnv *jEnv, jclass jClass, jint jSocketFileHandle)
     100{
     101        // Close the socket output stream
     102        shutdown(jSocketFileHandle, SHUT_WR);
     103}
  • source/com/sshtools/j2ssh/agent/AgentNotAvailableException.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29
     30/**
     31 *
     32 *
     33 * @author $author$
     34 * @version $Revision: 1.12 $
     35 */
     36public class AgentNotAvailableException extends Exception {
     37    /**
     38     * Creates a new AgentNotAvailableException object.
     39     */
     40    public AgentNotAvailableException() {
     41        super("An agent could not be found");
     42    }
     43        public AgentNotAvailableException(Exception e){
     44                super("An agent could not be found", e);
     45        }
     46}
  • source/com/sshtools/j2ssh/agent/AgentSocketChannel.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.connection.InvalidChannelException;
     30import com.sshtools.j2ssh.connection.SocketChannel;
     31import com.sshtools.j2ssh.io.ByteArrayWriter;
     32
     33import java.io.IOException;
     34
     35import java.net.InetAddress;
     36
     37
     38/**
     39 *
     40 *
     41 * @author $author$
     42 * @version $Revision: 1.11 $
     43 */
     44public class AgentSocketChannel extends SocketChannel {
     45    /**  */
     46    public static final String AGENT_FORWARDING_CHANNEL = "auth-agent";
     47
     48    //protected Socket socket = null;
     49    private boolean isForwarding;
     50
     51    /**
     52     * Creates a new AgentSocketChannel object.
     53     *
     54     * @param isForwarding
     55     */
     56    public AgentSocketChannel(boolean isForwarding) {
     57        this.isForwarding = isForwarding;
     58    }
     59
     60    /**
     61     *
     62     *
     63     * @return
     64     */
     65    public String getChannelType() {
     66        return AGENT_FORWARDING_CHANNEL;
     67    }
     68
     69    /*public void bindSocket(Socket socket) throws IOException {
     70       this.socket = socket;
     71       if (state.getValue() == ChannelState.CHANNEL_OPEN) {
     72         bindInputStream(socket.getInputStream());
     73         bindOutputStream(socket.getOutputStream());
     74       }
     75     }*/
     76    protected void onChannelRequest(String requestType, boolean wantReply,
     77        byte[] requestData) throws java.io.IOException {
     78        if (wantReply) {
     79            connection.sendChannelRequestFailure(this);
     80        }
     81    }
     82
     83    /**
     84     *
     85     *
     86     * @return
     87     */
     88    protected int getMaximumPacketSize() {
     89        return 32678;
     90    }
     91
     92    /*protected void onChannelClose() throws java.io.IOException {
     93     }
     94     protected void onChannelEOF() throws IOException {
     95     }*/
     96    public byte[] getChannelOpenData() {
     97        return null;
     98    }
     99
     100    /**
     101     *
     102     *
     103     * @return
     104     */
     105    protected int getMinimumWindowSpace() {
     106        return 1024;
     107    }
     108
     109    /**
     110     *
     111     *
     112     * @throws com.sshtools.j2ssh.connection.InvalidChannelException DOCUMENT
     113     *         ME!
     114     * @throws InvalidChannelException
     115     */
     116    protected void onChannelOpen()
     117        throws com.sshtools.j2ssh.connection.InvalidChannelException {
     118        try {
     119            //if (socket != null) {
     120            if (isForwarding) {
     121                // Were forwarding so insert the forwarding notice before any other data
     122                SshAgentForwardingNotice msg = new SshAgentForwardingNotice(InetAddress.getLocalHost()
     123                                                                                       .getHostName(),
     124                        InetAddress.getLocalHost().getHostAddress(),
     125                        socket.getPort());
     126                ByteArrayWriter baw = new ByteArrayWriter();
     127                msg.constructByteArray(baw);
     128                sendChannelData(baw.toByteArray());
     129            }
     130
     131            super.onChannelOpen();
     132
     133            // Now bind the socket to the channel
     134            //  bindInputStream(socket.getInputStream());
     135            //  bindOutputStream(socket.getOutputStream());
     136            //}
     137        } catch (IOException ex) {
     138            throw new InvalidChannelException(ex.getMessage());
     139        }
     140    }
     141
     142    /**
     143     *
     144     *
     145     * @return
     146     */
     147    protected int getMaximumWindowSpace() {
     148        return 32768;
     149    }
     150
     151    /**
     152     *
     153     *
     154     * @return
     155     */
     156    public byte[] getChannelConfirmationData() {
     157        return null;
     158    }
     159}
  • source/com/sshtools/j2ssh/agent/SshAgentVersionResponse.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.io.UnsignedInteger32;
     32import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     33import com.sshtools.j2ssh.transport.InvalidMessageException;
     34
     35import java.io.IOException;
     36
     37
     38class SshAgentVersionResponse extends SubsystemMessage {
     39    /**  */
     40    public static final int SSH_AGENT_VERSION_RESPONSE = 103;
     41    UnsignedInteger32 version;
     42
     43    /**
     44     * Creates a new SshAgentVersionResponse object.
     45     */
     46    public SshAgentVersionResponse() {
     47        super(SSH_AGENT_VERSION_RESPONSE);
     48    }
     49
     50    /**
     51     * Creates a new SshAgentVersionResponse object.
     52     *
     53     * @param version
     54     */
     55    public SshAgentVersionResponse(int version) {
     56        super(SSH_AGENT_VERSION_RESPONSE);
     57        this.version = new UnsignedInteger32(version);
     58    }
     59
     60    /**
     61     *
     62     *
     63     * @return
     64     */
     65    public int getVersion() {
     66        return version.intValue();
     67    }
     68
     69    /**
     70     *
     71     *
     72     * @return
     73     */
     74    public String getMessageName() {
     75        return "SSH_AGENT_VERSION_RESPONSE";
     76    }
     77
     78    /**
     79     *
     80     *
     81     * @param baw
     82     *
     83     * @throws java.io.IOException
     84     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     85     *         ME!
     86     * @throws InvalidMessageException
     87     */
     88    public void constructByteArray(ByteArrayWriter baw)
     89        throws java.io.IOException,
     90            com.sshtools.j2ssh.transport.InvalidMessageException {
     91        try {
     92            baw.writeUINT32(version);
     93        } catch (IOException ex) {
     94            throw new InvalidMessageException(ex.getMessage());
     95        }
     96    }
     97
     98    /**
     99     *
     100     *
     101     * @param bar
     102     *
     103     * @throws java.io.IOException
     104     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     105     *         ME!
     106     * @throws InvalidMessageException
     107     */
     108    public void constructMessage(ByteArrayReader bar)
     109        throws java.io.IOException,
     110            com.sshtools.j2ssh.transport.InvalidMessageException {
     111        try {
     112            version = bar.readUINT32();
     113        } catch (IOException ex) {
     114            throw new InvalidMessageException(ex.getMessage());
     115        }
     116    }
     117}
  • source/com/sshtools/j2ssh/agent/SshAgentForwardingNotice.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.io.UnsignedInteger32;
     32import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     33import com.sshtools.j2ssh.transport.InvalidMessageException;
     34
     35import java.io.IOException;
     36
     37
     38class SshAgentForwardingNotice extends SubsystemMessage {
     39    /**  */
     40    public static final int SSH_AGENT_FORWARDING_NOTICE = 206;
     41    String remoteHostname;
     42    String remoteIPAddress;
     43    UnsignedInteger32 remotePort;
     44
     45    /**
     46     * Creates a new SshAgentForwardingNotice object.
     47     */
     48    public SshAgentForwardingNotice() {
     49        super(SSH_AGENT_FORWARDING_NOTICE);
     50    }
     51
     52    /**
     53     * Creates a new SshAgentForwardingNotice object.
     54     *
     55     * @param remoteHostname
     56     * @param remoteIPAddress
     57     * @param remotePort
     58     */
     59    public SshAgentForwardingNotice(String remoteHostname,
     60        String remoteIPAddress, int remotePort) {
     61        super(SSH_AGENT_FORWARDING_NOTICE);
     62        this.remoteHostname = remoteHostname;
     63        this.remoteIPAddress = remoteIPAddress;
     64        this.remotePort = new UnsignedInteger32(remotePort);
     65    }
     66
     67    /**
     68     *
     69     *
     70     * @return
     71     */
     72    public String getRemoteHostname() {
     73        return remoteHostname;
     74    }
     75
     76    /**
     77     *
     78     *
     79     * @return
     80     */
     81    public String getRemoteIPAddress() {
     82        return remoteIPAddress;
     83    }
     84
     85    /**
     86     *
     87     *
     88     * @return
     89     */
     90    public int getRemotePort() {
     91        return remotePort.intValue();
     92    }
     93
     94    /**
     95     *
     96     *
     97     * @return
     98     */
     99    public String getMessageName() {
     100        return "SSH_AGENT_FORWARDING_NOTICE";
     101    }
     102
     103    /**
     104     *
     105     *
     106     * @param baw
     107     *
     108     * @throws java.io.IOException
     109     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     110     *         ME!
     111     * @throws InvalidMessageException
     112     */
     113    public void constructByteArray(ByteArrayWriter baw)
     114        throws java.io.IOException,
     115            com.sshtools.j2ssh.transport.InvalidMessageException {
     116        try {
     117            baw.writeString(remoteHostname);
     118            baw.writeString(remoteIPAddress);
     119            baw.writeUINT32(remotePort);
     120        } catch (IOException ex) {
     121            throw new InvalidMessageException(ex.getMessage());
     122        }
     123    }
     124
     125    /**
     126     *
     127     *
     128     * @param bar
     129     *
     130     * @throws java.io.IOException
     131     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     132     *         ME!
     133     * @throws InvalidMessageException
     134     */
     135    public void constructMessage(ByteArrayReader bar)
     136        throws java.io.IOException,
     137            com.sshtools.j2ssh.transport.InvalidMessageException {
     138        try {
     139            remoteHostname = bar.readString();
     140            remoteIPAddress = bar.readString();
     141            remotePort = bar.readUINT32();
     142        } catch (IOException ex) {
     143            throw new InvalidMessageException(ex.getMessage());
     144        }
     145    }
     146}
  • source/com/sshtools/j2ssh/agent/SshAgentListKeys.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32
     33
     34class SshAgentListKeys extends SubsystemMessage {
     35    /**  */
     36    public static final int SSH_AGENT_LIST_KEYS = 204;
     37
     38    /**
     39     * Creates a new SshAgentListKeys object.
     40     */
     41    public SshAgentListKeys() {
     42        super(SSH_AGENT_LIST_KEYS);
     43    }
     44
     45    /**
     46     *
     47     *
     48     * @return
     49     */
     50    public String getMessageName() {
     51        return "SSH_AGENT_LIST_KEYS";
     52    }
     53
     54    /**
     55     *
     56     *
     57     * @param baw
     58     *
     59     * @throws java.io.IOException
     60     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     61     *         ME!
     62     */
     63    public void constructByteArray(ByteArrayWriter baw)
     64        throws java.io.IOException,
     65            com.sshtools.j2ssh.transport.InvalidMessageException {
     66    }
     67
     68    /**
     69     *
     70     *
     71     * @param bar
     72     *
     73     * @throws java.io.IOException
     74     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     75     *         ME!
     76     */
     77    public void constructMessage(ByteArrayReader bar)
     78        throws java.io.IOException,
     79            com.sshtools.j2ssh.transport.InvalidMessageException {
     80    }
     81}
  • source/com/sshtools/j2ssh/agent/ForwardingNotice.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29class ForwardingNotice {
     30    String remoteHostname;
     31    String remoteIPAddress;
     32    int remotePort;
     33
     34    /**
     35     * Creates a new ForwardingNotice object.
     36     *
     37     * @param remoteHostname
     38     * @param remoteIPAddress
     39     * @param remotePort
     40     */
     41    public ForwardingNotice(String remoteHostname, String remoteIPAddress,
     42        int remotePort) {
     43        this.remoteHostname = remoteHostname;
     44        this.remoteIPAddress = remoteIPAddress;
     45        this.remotePort = remotePort;
     46    }
     47
     48    /**
     49     *
     50     *
     51     * @return
     52     */
     53    public String getRemoteHostname() {
     54        return remoteHostname;
     55    }
     56
     57    /**
     58     *
     59     *
     60     * @return
     61     */
     62    public String getRemoteIPAddress() {
     63        return remoteIPAddress;
     64    }
     65
     66    /**
     67     *
     68     *
     69     * @return
     70     */
     71    public int getRemotePort() {
     72        return remotePort;
     73    }
     74}
  • source/com/sshtools/j2ssh/agent/SshAgentSuccess.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32
     33
     34class SshAgentSuccess extends SubsystemMessage {
     35    /**  */
     36    public static final int SSH_AGENT_SUCCESS = 101;
     37
     38    /**
     39     * Creates a new SshAgentSuccess object.
     40     */
     41    public SshAgentSuccess() {
     42        super(SSH_AGENT_SUCCESS);
     43    }
     44
     45    /**
     46     *
     47     *
     48     * @return
     49     */
     50    public String getMessageName() {
     51        return "SSH_AGENT_SUCCESS";
     52    }
     53
     54    /**
     55     *
     56     *
     57     * @param baw
     58     *
     59     * @throws java.io.IOException
     60     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     61     *         ME!
     62     */
     63    public void constructByteArray(ByteArrayWriter baw)
     64        throws java.io.IOException,
     65            com.sshtools.j2ssh.transport.InvalidMessageException {
     66    }
     67
     68    /**
     69     *
     70     *
     71     * @param bar
     72     *
     73     * @throws java.io.IOException
     74     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     75     *         ME!
     76     */
     77    public void constructMessage(ByteArrayReader bar)
     78        throws java.io.IOException,
     79            com.sshtools.j2ssh.transport.InvalidMessageException {
     80    }
     81}
  • source/com/sshtools/j2ssh/agent/SshAgentForwardingListener.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.configuration.ConfigurationLoader;
     30import com.sshtools.j2ssh.connection.ConnectionProtocol;
     31import com.sshtools.j2ssh.util.StartStopState;
     32
     33import java.io.IOException;
     34
     35import java.net.InetAddress;
     36import java.net.ServerSocket;
     37import java.net.Socket;
     38
     39import java.util.HashMap;
     40import java.util.Vector;
     41
     42import org.apache.log4j.Logger;
     43
     44/**
     45 *
     46 *
     47 * @author $author$
     48 * @version $Revision: 1.16 $
     49 */
     50public class SshAgentForwardingListener {
     51        private static Logger log = Logger.getLogger(SshAgentForwardingListener.class);
     52    private static HashMap agents = new HashMap();
     53    ServerSocket server;
     54    int port;
     55    String location;
     56    StartStopState state = new StartStopState(StartStopState.STOPPED);
     57    Thread thread;
     58    ConnectionProtocol connection;
     59    Vector references = new Vector();
     60    String sessionId;
     61
     62    SshAgentForwardingListener(String sessionId, ConnectionProtocol connection) {
     63        this.sessionId = sessionId;
     64        this.connection = connection;
     65        port = selectPort();
     66        location = "localhost:" + String.valueOf(port);
     67        thread = new Thread(new Runnable() {
     68                    public void run() {
     69                        state.setValue(StartStopState.STARTED);
     70
     71                        try {
     72                            server = new ServerSocket(port, 5,
     73                                    InetAddress.getByName("localhost"));
     74
     75                            //server.bind(new InetSocketAddress("localhost", port));
     76                            Socket socket;
     77
     78                            while ((state.getValue() == StartStopState.STARTED) &&
     79                                    ((socket = server.accept()) != null)) {
     80                                AgentSocketChannel channel = new AgentSocketChannel(true);
     81                                channel.bindSocket(socket);
     82
     83                                if (!SshAgentForwardingListener.this.connection.openChannel(
     84                                            channel)) {
     85                                }
     86                            }
     87                        } catch (Exception e) {
     88                            if (state.getValue() == StartStopState.STARTED) {
     89                                log.warn("Forwarding agent socket failed", e);
     90                            }
     91                        }
     92
     93                        state.setValue(StartStopState.STOPPED);
     94                    }
     95                });
     96    }
     97
     98    /**
     99     *
     100     *
     101     * @return
     102     */
     103    public String getConfiguration() {
     104        return location;
     105    }
     106
     107    /**
     108     *
     109     *
     110     * @param obj
     111     */
     112    public void addReference(Object obj) {
     113        if (!references.contains(obj)) {
     114            references.add(obj);
     115        }
     116    }
     117
     118    /**
     119     *
     120     *
     121     * @param obj
     122     */
     123    public void removeReference(Object obj) {
     124        if (references.contains(obj)) {
     125            references.remove(obj);
     126
     127            if (references.size() == 0) {
     128                stop();
     129                agents.remove(sessionId);
     130            }
     131        }
     132    }
     133
     134    /**
     135     *
     136     *
     137     * @throws IOException
     138     */
     139    public void start() throws IOException {
     140        thread.start();
     141    }
     142
     143    /**
     144     *
     145     *
     146     * @return
     147     */
     148    public int getPort() {
     149        return port;
     150    }
     151
     152    /**
     153     *
     154     */
     155    public void stop() {
     156        try {
     157            state.setValue(StartStopState.STOPPED);
     158            server.close();
     159        } catch (IOException ex) {
     160        }
     161    }
     162
     163    private int selectPort() {
     164        return 49152 +
     165        (int) Math.round(((float) 16383 * ConfigurationLoader.getRND()
     166                                                             .nextFloat()));
     167    }
     168
     169    /**
     170     *
     171     *
     172     * @param sessionId
     173     * @param connection
     174     *
     175     * @return
     176     *
     177     * @throws AgentNotAvailableException
     178     */
     179    public static SshAgentForwardingListener getInstance(String sessionId,
     180        ConnectionProtocol connection) throws AgentNotAvailableException {
     181        if (agents.containsKey(sessionId)) {
     182            SshAgentForwardingListener agent = (SshAgentForwardingListener) agents.get(sessionId);
     183
     184            return agent;
     185        } else {
     186            try {
     187                SshAgentForwardingListener agent = new SshAgentForwardingListener(sessionId,
     188                        connection);
     189                agent.start();
     190                agents.put(sessionId, agent);
     191
     192                return agent;
     193            } catch (IOException ex) {
     194                throw new AgentNotAvailableException();
     195            }
     196        }
     197    }
     198}
  • source/com/sshtools/j2ssh/agent/KeyStore.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.transport.publickey.*;
     30
     31import java.io.*;
     32
     33import java.util.*;
     34
     35
     36/**
     37 *
     38 *
     39 * @author $author$
     40 * @version $Revision: 1.14 $
     41 */
     42public class KeyStore {
     43    HashMap publickeys = new HashMap();
     44    HashMap privatekeys = new HashMap();
     45    HashMap constraints = new HashMap();
     46    Vector index = new Vector();
     47    Vector listeners = new Vector();
     48    String lockedPassword = null;
     49
     50    /**
     51     * Creates a new KeyStore object.
     52     */
     53    public KeyStore() {
     54    }
     55
     56    /**
     57     *
     58     *
     59     * @return
     60     */
     61    public Map getPublicKeys() {
     62        return (Map) publickeys.clone();
     63    }
     64
     65    /**
     66     *
     67     *
     68     * @param key
     69     *
     70     * @return
     71     */
     72    public int indexOf(SshPublicKey key) {
     73        return index.indexOf(key);
     74    }
     75
     76    /**
     77     *
     78     *
     79     * @param i
     80     *
     81     * @return
     82     */
     83    public SshPublicKey elementAt(int i) {
     84        return (SshPublicKey) index.elementAt(i);
     85    }
     86
     87    /**
     88     *
     89     *
     90     * @param key
     91     *
     92     * @return
     93     */
     94    public String getDescription(SshPublicKey key) {
     95        return (String) publickeys.get(key);
     96    }
     97
     98    /**
     99     *
     100     *
     101     * @param key
     102     *
     103     * @return
     104     */
     105    public KeyConstraints getKeyConstraints(SshPublicKey key) {
     106        return (KeyConstraints) constraints.get(key);
     107    }
     108
     109    /**
     110     *
     111     *
     112     * @return
     113     */
     114    public int size() {
     115        return index.size();
     116    }
     117
     118    /**
     119     *
     120     *
     121     * @param listener
     122     */
     123    public void addKeyStoreListener(KeyStoreListener listener) {
     124        listeners.add(listener);
     125    }
     126
     127    /**
     128     *
     129     *
     130     * @param listener
     131     */
     132    public void removeKeyStoreListener(KeyStoreListener listener) {
     133        listeners.remove(listener);
     134    }
     135
     136    /**
     137     *
     138     *
     139     * @param prvkey
     140     * @param pubkey
     141     * @param description
     142     * @param cs
     143     *
     144     * @return
     145     *
     146     * @throws IOException
     147     */
     148    public boolean addKey(SshPrivateKey prvkey, SshPublicKey pubkey,
     149        String description, KeyConstraints cs) throws IOException {
     150        synchronized (publickeys) {
     151            if (!publickeys.containsKey(pubkey)) {
     152                publickeys.put(pubkey, description);
     153                privatekeys.put(pubkey, prvkey);
     154                constraints.put(pubkey, cs);
     155                index.add(pubkey);
     156
     157                Iterator it = listeners.iterator();
     158                KeyStoreListener listener;
     159
     160                while (it.hasNext()) {
     161                    listener = (KeyStoreListener) it.next();
     162                    listener.onAddKey(this);
     163                }
     164
     165                return true;
     166            } else {
     167                return false;
     168            }
     169        }
     170    }
     171
     172    /**
     173     *
     174     */
     175    public void deleteAllKeys() {
     176        synchronized (publickeys) {
     177            publickeys.clear();
     178            privatekeys.clear();
     179            constraints.clear();
     180            index.clear();
     181
     182            Iterator it = listeners.iterator();
     183            KeyStoreListener listener;
     184
     185            while (it.hasNext()) {
     186                listener = (KeyStoreListener) it.next();
     187                listener.onDeleteAllKeys(this);
     188            }
     189        }
     190    }
     191
     192    /**
     193     *
     194     *
     195     * @param pubkey
     196     * @param forwardingNodes
     197     * @param data
     198     *
     199     * @return
     200     *
     201     * @throws KeyTimeoutException
     202     * @throws InvalidSshKeyException
     203     * @throws InvalidSshKeySignatureException
     204     */
     205    public byte[] performHashAndSign(SshPublicKey pubkey, List forwardingNodes,
     206        byte[] data)
     207        throws KeyTimeoutException, InvalidSshKeyException,
     208            InvalidSshKeySignatureException {
     209        synchronized (publickeys) {
     210            if (privatekeys.containsKey(pubkey)) {
     211                SshPrivateKey key = (SshPrivateKey) privatekeys.get(pubkey);
     212                KeyConstraints cs = (KeyConstraints) constraints.get(pubkey);
     213
     214                if (cs.canUse()) {
     215                    if (!cs.hasTimedOut()) {
     216                        cs.use();
     217
     218                        byte[] sig = key.generateSignature(data);
     219                        Iterator it = listeners.iterator();
     220                        KeyStoreListener listener;
     221
     222                        while (it.hasNext()) {
     223                            listener = (KeyStoreListener) it.next();
     224                            listener.onKeyOperation(this, "hash-and-sign");
     225                        }
     226
     227                        return sig;
     228                    } else {
     229                        throw new KeyTimeoutException();
     230                    }
     231                } else {
     232                    throw new KeyTimeoutException();
     233                }
     234            } else {
     235                throw new InvalidSshKeyException("The key does not exist");
     236            }
     237        }
     238    }
     239
     240    /**
     241     *
     242     *
     243     * @param pubkey
     244     * @param description
     245     *
     246     * @return
     247     *
     248     * @throws IOException
     249     */
     250    public boolean deleteKey(SshPublicKey pubkey, String description)
     251        throws IOException {
     252        synchronized (publickeys) {
     253            if (publickeys.containsKey(pubkey)) {
     254                String desc = (String) publickeys.get(pubkey);
     255
     256                if (description.equals(desc)) {
     257                    publickeys.remove(pubkey);
     258                    privatekeys.remove(pubkey);
     259                    constraints.remove(pubkey);
     260                    index.remove(pubkey);
     261
     262                    Iterator it = listeners.iterator();
     263                    KeyStoreListener listener;
     264
     265                    while (it.hasNext()) {
     266                        listener = (KeyStoreListener) it.next();
     267                        listener.onDeleteKey(this);
     268                    }
     269
     270                    return true;
     271                }
     272            }
     273
     274            return false;
     275        }
     276    }
     277
     278    /**
     279     *
     280     *
     281     * @param password
     282     *
     283     * @return
     284     *
     285     * @throws IOException
     286     */
     287    public boolean lock(String password) throws IOException {
     288        synchronized (publickeys) {
     289            if (lockedPassword == null) {
     290                lockedPassword = password;
     291
     292                Iterator it = listeners.iterator();
     293                KeyStoreListener listener;
     294
     295                while (it.hasNext()) {
     296                    listener = (KeyStoreListener) it.next();
     297                    listener.onLock(this);
     298                }
     299
     300                return true;
     301            } else {
     302                return false;
     303            }
     304        }
     305    }
     306
     307    /**
     308     *
     309     *
     310     * @param password
     311     *
     312     * @return
     313     *
     314     * @throws IOException
     315     */
     316    public boolean unlock(String password) throws IOException {
     317        synchronized (publickeys) {
     318            if (lockedPassword != null) {
     319                if (password.equals(lockedPassword)) {
     320                    lockedPassword = null;
     321
     322                    Iterator it = listeners.iterator();
     323                    KeyStoreListener listener;
     324
     325                    while (it.hasNext()) {
     326                        listener = (KeyStoreListener) it.next();
     327                        listener.onUnlock(this);
     328                    }
     329
     330                    return true;
     331                }
     332            }
     333
     334            return false;
     335        }
     336    }
     337}
  • source/com/sshtools/j2ssh/agent/SshAgentRandomData.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32import com.sshtools.j2ssh.transport.InvalidMessageException;
     33
     34import java.io.IOException;
     35
     36
     37class SshAgentRandomData extends SubsystemMessage {
     38    /**  */
     39    public static final int SSH_AGENT_RANDOM_DATA = 106;
     40    private byte[] data;
     41
     42    /**
     43     * Creates a new SshAgentRandomData object.
     44     */
     45    public SshAgentRandomData() {
     46        super(SSH_AGENT_RANDOM_DATA);
     47    }
     48
     49    /**
     50     * Creates a new SshAgentRandomData object.
     51     *
     52     * @param data
     53     */
     54    public SshAgentRandomData(byte[] data) {
     55        super(SSH_AGENT_RANDOM_DATA);
     56        this.data = data;
     57    }
     58
     59    /**
     60     *
     61     *
     62     * @return
     63     */
     64    public byte[] getRandomData() {
     65        return data;
     66    }
     67
     68    /**
     69     *
     70     *
     71     * @return
     72     */
     73    public String getMessageName() {
     74        return "SSH_AGENT_RANDOM_DATA";
     75    }
     76
     77    /**
     78     *
     79     *
     80     * @param baw
     81     *
     82     * @throws java.io.IOException
     83     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     84     *         ME!
     85     * @throws InvalidMessageException
     86     */
     87    public void constructByteArray(ByteArrayWriter baw)
     88        throws java.io.IOException,
     89            com.sshtools.j2ssh.transport.InvalidMessageException {
     90        try {
     91            baw.writeBinaryString(data);
     92        } catch (IOException ioe) {
     93            throw new InvalidMessageException(ioe.getMessage());
     94        }
     95    }
     96
     97    /**
     98     *
     99     *
     100     * @param bar
     101     *
     102     * @throws java.io.IOException
     103     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     104     *         ME!
     105     * @throws InvalidMessageException
     106     */
     107    public void constructMessage(ByteArrayReader bar)
     108        throws java.io.IOException,
     109            com.sshtools.j2ssh.transport.InvalidMessageException {
     110        try {
     111            data = bar.readBinaryString();
     112        } catch (IOException ioe) {
     113            throw new InvalidMessageException(ioe.getMessage());
     114        }
     115    }
     116}
  • source/com/sshtools/j2ssh/agent/SshAgentDeleteKey.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32import com.sshtools.j2ssh.transport.InvalidMessageException;
     33import com.sshtools.j2ssh.transport.publickey.SshKeyPairFactory;
     34import com.sshtools.j2ssh.transport.publickey.SshPublicKey;
     35
     36import java.io.IOException;
     37
     38
     39class SshAgentDeleteKey extends SubsystemMessage {
     40    /**  */
     41    public static final int SSH_AGENT_DELETE_KEY = 207;
     42    SshPublicKey pubkey;
     43    String description;
     44
     45    /**
     46     * Creates a new SshAgentDeleteKey object.
     47     */
     48    public SshAgentDeleteKey() {
     49        super(SSH_AGENT_DELETE_KEY);
     50    }
     51
     52    /**
     53     * Creates a new SshAgentDeleteKey object.
     54     *
     55     * @param pubkey
     56     * @param description
     57     */
     58    public SshAgentDeleteKey(SshPublicKey pubkey, String description) {
     59        super(SSH_AGENT_DELETE_KEY);
     60        this.pubkey = pubkey;
     61        this.description = description;
     62    }
     63
     64    /**
     65     *
     66     *
     67     * @return
     68     */
     69    public SshPublicKey getPublicKey() {
     70        return pubkey;
     71    }
     72
     73    /**
     74     *
     75     *
     76     * @return
     77     */
     78    public String getDescription() {
     79        return description;
     80    }
     81
     82    /**
     83     *
     84     *
     85     * @return
     86     */
     87    public String getMessageName() {
     88        return "SSH_AGENT_DELETE_KEY";
     89    }
     90
     91    /**
     92     *
     93     *
     94     * @param baw
     95     *
     96     * @throws java.io.IOException
     97     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     98     *         ME!
     99     * @throws InvalidMessageException
     100     */
     101    public void constructByteArray(ByteArrayWriter baw)
     102        throws java.io.IOException,
     103            com.sshtools.j2ssh.transport.InvalidMessageException {
     104        try {
     105            baw.writeBinaryString(pubkey.getEncoded());
     106            baw.writeString(description);
     107        } catch (IOException ex) {
     108            throw new InvalidMessageException(ex.getMessage());
     109        }
     110    }
     111
     112    /**
     113     *
     114     *
     115     * @param bar
     116     *
     117     * @throws java.io.IOException
     118     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     119     *         ME!
     120     * @throws InvalidMessageException
     121     */
     122    public void constructMessage(ByteArrayReader bar)
     123        throws java.io.IOException,
     124            com.sshtools.j2ssh.transport.InvalidMessageException {
     125        try {
     126            pubkey = SshKeyPairFactory.decodePublicKey(bar.readBinaryString());
     127            description = bar.readString();
     128        } catch (IOException ex) {
     129            throw new InvalidMessageException(ex.getMessage());
     130        }
     131    }
     132}
  • source/com/sshtools/j2ssh/agent/KeyStoreListener.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29
     30/**
     31 *
     32 *
     33 * @author $author$
     34 * @version $Revision: 1.12 $
     35 */
     36public interface KeyStoreListener {
     37    /**
     38     *
     39     *
     40     * @param keystore
     41     */
     42    public void onDeleteKey(KeyStore keystore);
     43
     44    /**
     45     *
     46     *
     47     * @param keystore
     48     */
     49    public void onLock(KeyStore keystore);
     50
     51    /**
     52     *
     53     *
     54     * @param keystore
     55     */
     56    public void onUnlock(KeyStore keystore);
     57
     58    /**
     59     *
     60     *
     61     * @param keystore
     62     */
     63    public void onAddKey(KeyStore keystore);
     64
     65    /**
     66     *
     67     *
     68     * @param keystore
     69     */
     70    public void onDeleteAllKeys(KeyStore keystore);
     71
     72    /**
     73     *
     74     *
     75     * @param keystore
     76     * @param operation
     77     */
     78    public void onKeyOperation(KeyStore keystore, String operation);
     79}
  • source/com/sshtools/j2ssh/agent/SshAgentClient.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.echogent.jbuds.UnixDomainSocket;
     30
     31import com.sshtools.j2ssh.io.ByteArrayReader;
     32import com.sshtools.j2ssh.io.ByteArrayWriter;
     33import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     34import com.sshtools.j2ssh.transport.InvalidMessageException;
     35import com.sshtools.j2ssh.transport.publickey.SshPrivateKey;
     36import com.sshtools.j2ssh.transport.publickey.SshPublicKey;
     37import org.apache.log4j.Logger;
     38import java.io.FileOutputStream;
     39import java.io.FileInputStream;
     40import java.io.IOException;
     41import java.io.InputStream;
     42import java.io.OutputStream;
     43
     44import java.net.InetAddress;
     45import java.net.Socket;
     46
     47import java.util.Arrays;
     48import java.util.HashMap;
     49import java.util.Map;
     50
     51
     52/**
     53 * Provides a client connection to the ssh agent.
     54 *
     55 * @author $author$
     56 * @version $Revision: 1.17 $
     57 */
     58public class SshAgentClient {
     59        private static Logger log = Logger.getLogger(SshAgentClient.class);
     60    /** The hash and sign private key operation */
     61    public static final String HASH_AND_SIGN = "hash-and-sign";
     62    InputStream in;
     63    OutputStream out;
     64    boolean isForwarded = false;
     65    HashMap messages = new HashMap();
     66    Socket socket;
     67        UnixDomainSocket udSocket;
     68
     69    SshAgentClient(boolean isForwarded, String application, InputStream in,
     70        OutputStream out) throws IOException {
     71        log.info("New SshAgentClient instance created");
     72        this.in = in;
     73        this.out = out;
     74        this.isForwarded = isForwarded;
     75        registerMessages();
     76
     77        if (isForwarded) {
     78            sendForwardingNotice();
     79        } else {
     80            sendVersionRequest(application);
     81        }
     82    }
     83
     84    SshAgentClient(boolean isForwarded, String application, Socket socket)
     85        throws IOException {
     86        log.info("New SshAgentClient instance created");
     87        this.socket = socket;
     88        this.in = socket.getInputStream();
     89        this.out = socket.getOutputStream();
     90        this.isForwarded = isForwarded;
     91        registerMessages();
     92
     93        if (isForwarded) {
     94            sendForwardingNotice();
     95        } else {
     96            sendVersionRequest(application);
     97        }
     98    }
     99
     100    SshAgentClient(boolean isForwarded, String application, UnixDomainSocket socket)
     101        throws IOException {
     102        log.info("New SshAgentClient instance created");
     103        this.udSocket = socket;
     104        this.in = socket.getInputStream();
     105        this.out = socket.getOutputStream();
     106        this.isForwarded = isForwarded;
     107        registerMessages();
     108
     109        if (isForwarded) {
     110            sendForwardingNotice();
     111        } else {
     112            sendVersionRequest(application);
     113        }
     114    }
     115       
     116        /**
     117     * Connect to the local agent.
     118     *
     119     * @param application the application connecting
     120     * @param location the location of the agent, in the form "localhost:port" or
     121         * a pathname indicating a named pipe.
     122     *
     123     * @return a connected agent client
     124     *
     125     * @throws AgentNotAvailableException if the agent is not available at the
     126     *         location specified
     127     * @throws IOException if an IO error occurs
     128     */
     129    public static SshAgentClient connectLocalAgent(String application,
     130        String location) throws AgentNotAvailableException, IOException {
     131        try {
     132            Socket socket = connectAgentSocket(location);
     133                        if (socket != null)
     134                                return new SshAgentClient(false, application, socket);
     135                        else
     136                                return new SshAgentClient(false, application, connectLocalAgentSocket(location));
     137        } catch (IOException ex) {
     138            throw new AgentNotAvailableException(ex);
     139        }
     140    }
     141
     142        private static UnixDomainSocket connectLocalAgentSocket(String location) throws IOException {
     143                log.fatal("connecting to agent socket "+location);
     144                return new UnixDomainSocket(location);
     145        }
     146
     147    /**
     148     * Connect a socket to the agent at the location specified.
     149     *
     150     * @param location the location of the agent, in the form "localhost:port"      *
     151     * @return the connected socket
     152     *
     153     * @throws AgentNotAvailableException if an agent is not available at the
     154     *         location specified
     155     * @throws IOException if an IO error occurs
     156     */
     157    public static Socket connectAgentSocket(String location)
     158        throws AgentNotAvailableException, IOException {
     159        try {
     160            if (location == null) {
     161                throw new AgentNotAvailableException();
     162            }
     163
     164            int idx = location.indexOf(":");
     165
     166            if (idx == -1) {
     167                            // assume it's a named pipe
     168                                return null;
     169            }
     170
     171            String host = location.substring(0, idx);
     172            int port = Integer.parseInt(location.substring(idx + 1));
     173            Socket socket = new Socket(host, port);
     174
     175            return socket;
     176        } catch (IOException ex) {
     177            throw new AgentNotAvailableException();
     178        }
     179    }
     180
     181    /**
     182     * Close the agent
     183     */
     184    public void close() {
     185        log.info("Closing agent client");
     186
     187        try {
     188            in.close();
     189        } catch (IOException ex) {
     190        }
     191
     192        try {
     193            out.close();
     194        } catch (IOException ex1) {
     195        }
     196
     197        try {
     198            if (socket != null) {
     199                socket.close();
     200            }
     201        } catch (IOException ex2) {
     202        }
     203        if (udSocket != null) {
     204            udSocket.close();
     205        }
     206    }
     207
     208    /**
     209     * Register the subsystem messages
     210     */
     211    protected void registerMessages() {
     212        messages.put(new Integer(
     213                SshAgentVersionResponse.SSH_AGENT_VERSION_RESPONSE),
     214            SshAgentVersionResponse.class);
     215        messages.put(new Integer(SshAgentSuccess.SSH_AGENT_SUCCESS),
     216            SshAgentSuccess.class);
     217        messages.put(new Integer(SshAgentFailure.SSH_AGENT_FAILURE),
     218            SshAgentFailure.class);
     219        messages.put(new Integer(SshAgentKeyList.SSH_AGENT_KEY_LIST),
     220            SshAgentKeyList.class);
     221        messages.put(new Integer(SshAgentRandomData.SSH_AGENT_RANDOM_DATA),
     222            SshAgentRandomData.class);
     223        messages.put(new Integer(SshAgentAlive.SSH_AGENT_ALIVE),
     224            SshAgentAlive.class);
     225        messages.put(new Integer(
     226                SshAgentOperationComplete.SSH_AGENT_OPERATION_COMPLETE),
     227            SshAgentOperationComplete.class);
     228    }
     229
     230    /**
     231     * Request the agent version.
     232     *
     233     * @param application the application connecting
     234     *
     235     * @throws IOException if an IO error occurs
     236     */
     237    protected void sendVersionRequest(String application)
     238        throws IOException {
     239        SubsystemMessage msg = new SshAgentRequestVersion(application);
     240        sendMessage(msg);
     241        msg = readMessage();
     242
     243        if (msg instanceof SshAgentVersionResponse) {
     244            SshAgentVersionResponse reply = (SshAgentVersionResponse) msg;
     245
     246            if (reply.getVersion() != 2) {
     247                throw new IOException(
     248                    "The agent verison is not compatible with verison 2");
     249            }
     250        } else {
     251            throw new IOException(
     252                "The agent did not respond with the appropriate version");
     253        }
     254    }
     255
     256    /**
     257     * Add a key to the agent
     258     *
     259     * @param prvkey the private key to add
     260     * @param pubkey the private keys public key
     261     * @param description a description of the key
     262     * @param constraints a set of contraints for key use
     263     *
     264     * @throws IOException if an IO error occurs
     265     */
     266    public void addKey(SshPrivateKey prvkey, SshPublicKey pubkey,
     267        String description, KeyConstraints constraints)
     268        throws IOException {
     269        SubsystemMessage msg = new SshAgentAddKey(prvkey, pubkey, description,
     270                constraints);
     271        sendMessage(msg);
     272        msg = readMessage();
     273
     274        if (!(msg instanceof SshAgentSuccess)) {
     275            throw new IOException("The key could not be added");
     276        }
     277    }
     278
     279    /**
     280     * Request a hash and sign operation be performed for a given public key.
     281     *
     282     * @param key the public key of the required private key
     283     * @param data the data to has and sign
     284     *
     285     * @return the hashed and signed data
     286     *
     287     * @throws IOException if an IO error occurs
     288     */
     289    public byte[] hashAndSign(SshPublicKey key, byte[] data)
     290        throws IOException {
     291        SubsystemMessage msg = new SshAgentPrivateKeyOp(key, HASH_AND_SIGN, data);
     292        sendMessage(msg);
     293        msg = readMessage();
     294
     295        if (msg instanceof SshAgentOperationComplete) {
     296            return ((SshAgentOperationComplete) msg).getData();
     297        } else {
     298            throw new IOException("The operation failed");
     299        }
     300    }
     301
     302    /**
     303     * List all the keys on the agent.
     304     *
     305     * @return a map of public keys and descriptions
     306     *
     307     * @throws IOException if an IO error occurs
     308     */
     309    public Map listKeys() throws IOException {
     310        SubsystemMessage msg = new SshAgentListKeys();
     311        sendMessage(msg);
     312        msg = readMessage();
     313
     314        if (msg instanceof SshAgentKeyList) {
     315            return ((SshAgentKeyList) msg).getKeys();
     316        } else {
     317            throw new IOException("The agent responsed with an invalid message");
     318        }
     319    }
     320
     321    /**
     322     * Lock the agent
     323     *
     324     * @param password password that will be required to unlock
     325     *
     326     * @return true if the agent was locked, otherwise false
     327     *
     328     * @throws IOException if an IO error occurs
     329     */
     330    public boolean lockAgent(String password) throws IOException {
     331        SubsystemMessage msg = new SshAgentLock(password);
     332        sendMessage(msg);
     333        msg = readMessage();
     334
     335        return (msg instanceof SshAgentSuccess);
     336    }
     337
     338    /**
     339     * Unlock the agent
     340     *
     341     * @param password the password to unlock
     342     *
     343     * @return true if the agent was unlocked, otherwise false
     344     *
     345     * @throws IOException if an IO error occurs
     346     */
     347    public boolean unlockAgent(String password) throws IOException {
     348        SubsystemMessage msg = new SshAgentUnlock(password);
     349        sendMessage(msg);
     350        msg = readMessage();
     351
     352        return (msg instanceof SshAgentSuccess);
     353    }
     354
     355    /**
     356     * Request some random data from the remote side
     357     *
     358     * @param count the number of bytes needed
     359     *
     360     * @return the random data received
     361     *
     362     * @throws IOException if an IO error occurs
     363     */
     364    public byte[] getRandomData(int count) throws IOException {
     365        SubsystemMessage msg = new SshAgentRandom(count);
     366        sendMessage(msg);
     367        msg = readMessage();
     368
     369        if (msg instanceof SshAgentRandomData) {
     370            return ((SshAgentRandomData) msg).getRandomData();
     371        } else {
     372            throw new IOException(
     373                "Agent failed to provide the request random data");
     374        }
     375    }
     376
     377    /**
     378     * Ping the remote side with some random padding data
     379     *
     380     * @param padding the padding data
     381     *
     382     * @throws IOException if an IO error occurs
     383     */
     384    public void ping(byte[] padding) throws IOException {
     385        SubsystemMessage msg = new SshAgentPing(padding);
     386        sendMessage(msg);
     387        msg = readMessage();
     388
     389        if (msg instanceof SshAgentAlive) {
     390            if (!Arrays.equals(padding, ((SshAgentAlive) msg).getPadding())) {
     391                throw new IOException(
     392                    "Agent failed to reply with expected data");
     393            }
     394        } else {
     395            throw new IOException(
     396                "Agent failed to provide the request random data");
     397        }
     398    }
     399
     400    /**
     401     * Delete a key held by the agent
     402     *
     403     * @param key the public key of the private key to delete
     404     * @param description the description of the key
     405     *
     406     * @throws IOException if an IO error occurs
     407     */
     408    public void deleteKey(SshPublicKey key, String description)
     409        throws IOException {
     410        SubsystemMessage msg = new SshAgentDeleteKey(key, description);
     411        sendMessage(msg);
     412        msg = readMessage();
     413
     414        if (!(msg instanceof SshAgentSuccess)) {
     415            throw new IOException("The agent failed to delete the key");
     416        }
     417    }
     418
     419    /**
     420     * Delete all the keys held by the agent.
     421     *
     422     * @throws IOException if an IO error occurs
     423     */
     424    public void deleteAllKeys() throws IOException {
     425        SubsystemMessage msg = new SshAgentDeleteAllKeys();
     426        sendMessage(msg);
     427        msg = readMessage();
     428
     429        if (!(msg instanceof SshAgentSuccess)) {
     430            throw new IOException("The agent failed to delete all keys");
     431        }
     432    }
     433
     434    /**
     435     * Send a forwarding notice.
     436     *
     437     * @throws IOException if an IO error occurs
     438     */
     439    protected void sendForwardingNotice() throws IOException {
     440        InetAddress addr = InetAddress.getLocalHost();
     441        SshAgentForwardingNotice msg = new SshAgentForwardingNotice(addr.getHostName(),
     442                addr.getHostAddress(), 22);
     443        sendMessage(msg);
     444    }
     445
     446    /**
     447     * Send a subsystem message
     448     *
     449     * @param msg the message to send
     450     *
     451     * @throws IOException if an IO error occurs
     452     */
     453    protected void sendMessage(SubsystemMessage msg) throws IOException {
     454        log.info("Sending message " + msg.getMessageName());
     455
     456                ByteArrayWriter bow = new ByteArrayWriter();
     457                msg.constructByteArray(bow);
     458        byte[] msgdata = bow.toByteArray();
     459                out.write(ByteArrayWriter.encodeInt(msgdata.length));
     460        out.write(msgdata);
     461        out.flush();
     462    }
     463
     464    /**
     465     * Read a single message from the inputstream and convert into a valid
     466     * subsystem message
     467     *
     468     * @return the next available subsystem message
     469     *
     470     * @throws InvalidMessageException if the message received is invalid
     471     */
     472    protected SubsystemMessage readMessage() throws InvalidMessageException {
     473        try {
     474            byte[] lendata = new byte[4];
     475            byte[] msgdata;
     476            int len;
     477
     478            // Read the first 4 bytes to determine the length of the message
     479            len = 0;
     480
     481            while (len < 3) {
     482                len += in.read(lendata, len, lendata.length - len);
     483            }
     484
     485            len = (int) ByteArrayReader.readInt(lendata, 0);
     486            msgdata = new byte[len];
     487            len = 0;
     488
     489            while (len < msgdata.length) {
     490                len += in.read(msgdata, len, msgdata.length - len);
     491            }
     492
     493            Integer id = new Integer((int) msgdata[0] & 0xFF);
     494
     495            if (messages.containsKey(id)) {
     496                Class cls = (Class) messages.get(id);
     497                SubsystemMessage msg = (SubsystemMessage) cls.newInstance();
     498                msg.fromByteArray(new ByteArrayReader(msgdata));
     499                log.info("Received message " + msg.getMessageName());
     500
     501                return msg;
     502            } else {
     503                throw new InvalidMessageException("Unrecognised message id " +
     504                    id.toString());
     505            }
     506        } catch (Exception ex) {
     507            throw new InvalidMessageException(ex.getMessage());
     508        }
     509    }
     510}
  • source/com/sshtools/j2ssh/agent/SshAgentRandom.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32import com.sshtools.j2ssh.transport.InvalidMessageException;
     33
     34import java.io.IOException;
     35
     36
     37class SshAgentRandom extends SubsystemMessage {
     38    /**  */
     39    public static final int SSH_AGENT_RANDOM = 213;
     40    private int length;
     41
     42    /**
     43     * Creates a new SshAgentRandom object.
     44     */
     45    public SshAgentRandom() {
     46        super(SSH_AGENT_RANDOM);
     47    }
     48
     49    /**
     50     * Creates a new SshAgentRandom object.
     51     *
     52     * @param length
     53     */
     54    public SshAgentRandom(int length) {
     55        super(SSH_AGENT_RANDOM);
     56        this.length = length;
     57    }
     58
     59    /**
     60     *
     61     *
     62     * @return
     63     */
     64    public int getLength() {
     65        return length;
     66    }
     67
     68    /**
     69     *
     70     *
     71     * @return
     72     */
     73    public String getMessageName() {
     74        return "SSH_AGENT_RANDOM";
     75    }
     76
     77    /**
     78     *
     79     *
     80     * @param baw
     81     *
     82     * @throws java.io.IOException
     83     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     84     *         ME!
     85     * @throws InvalidMessageException
     86     */
     87    public void constructByteArray(ByteArrayWriter baw)
     88        throws java.io.IOException,
     89            com.sshtools.j2ssh.transport.InvalidMessageException {
     90        try {
     91            baw.writeInt(length);
     92        } catch (IOException ioe) {
     93            throw new InvalidMessageException(ioe.getMessage());
     94        }
     95    }
     96
     97    /**
     98     *
     99     *
     100     * @param bar
     101     *
     102     * @throws java.io.IOException
     103     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     104     *         ME!
     105     * @throws InvalidMessageException
     106     */
     107    public void constructMessage(ByteArrayReader bar)
     108        throws java.io.IOException,
     109            com.sshtools.j2ssh.transport.InvalidMessageException {
     110        try {
     111            length = (int) bar.readInt();
     112        } catch (IOException ioe) {
     113            throw new InvalidMessageException(ioe.getMessage());
     114        }
     115    }
     116}
  • source/com/sshtools/j2ssh/agent/KeyTimeoutException.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29
     30/**
     31 *
     32 *
     33 * @author $author$
     34 * @version $Revision: 1.12 $
     35 */
     36public class KeyTimeoutException extends Exception {
     37    /**
     38     * Creates a new KeyTimeoutException object.
     39     */
     40    public KeyTimeoutException() {
     41        super("The key has timed out");
     42    }
     43}
  • source/com/sshtools/j2ssh/agent/SshAgentPrivateKeyOp.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32import com.sshtools.j2ssh.transport.InvalidMessageException;
     33import com.sshtools.j2ssh.transport.publickey.SshKeyPairFactory;
     34import com.sshtools.j2ssh.transport.publickey.SshPublicKey;
     35
     36import java.io.IOException;
     37
     38
     39class SshAgentPrivateKeyOp extends SubsystemMessage {
     40    /**  */
     41    public static final int SSH_AGENT_PRIVATE_KEY_OP = 205;
     42    SshPublicKey pubkey;
     43    String operation;
     44    byte[] data;
     45
     46    /**
     47     * Creates a new SshAgentPrivateKeyOp object.
     48     */
     49    public SshAgentPrivateKeyOp() {
     50        super(SSH_AGENT_PRIVATE_KEY_OP);
     51    }
     52
     53    /**
     54     * Creates a new SshAgentPrivateKeyOp object.
     55     *
     56     * @param pubkey
     57     * @param operation
     58     * @param data
     59     */
     60    public SshAgentPrivateKeyOp(SshPublicKey pubkey, String operation,
     61        byte[] data) {
     62        super(SSH_AGENT_PRIVATE_KEY_OP);
     63        this.pubkey = pubkey;
     64        this.operation = operation;
     65        this.data = data;
     66    }
     67
     68    /**
     69     *
     70     *
     71     * @return
     72     */
     73    public SshPublicKey getPublicKey() {
     74        return pubkey;
     75    }
     76
     77    /**
     78     *
     79     *
     80     * @return
     81     */
     82    public String getOperation() {
     83        return operation;
     84    }
     85
     86    /**
     87     *
     88     *
     89     * @return
     90     */
     91    public byte[] getOperationData() {
     92        return data;
     93    }
     94
     95    /**
     96     *
     97     *
     98     * @return
     99     */
     100    public String getMessageName() {
     101        return "SSH_AGENT_PRIVATE_KEY_OP";
     102    }
     103
     104    /**
     105     *
     106     *
     107     * @param baw
     108     *
     109     * @throws java.io.IOException
     110     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     111     *         ME!
     112     * @throws InvalidMessageException
     113     */
     114    public void constructByteArray(ByteArrayWriter baw)
     115        throws java.io.IOException,
     116            com.sshtools.j2ssh.transport.InvalidMessageException {
     117        try {
     118            baw.writeString(operation);
     119            baw.writeBinaryString(pubkey.getEncoded());
     120            baw.write(data);
     121        } catch (IOException ex) {
     122            throw new InvalidMessageException(ex.getMessage());
     123        }
     124    }
     125
     126    /**
     127     *
     128     *
     129     * @param bar
     130     *
     131     * @throws java.io.IOException
     132     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     133     *         ME!
     134     * @throws InvalidMessageException
     135     */
     136    public void constructMessage(ByteArrayReader bar)
     137        throws java.io.IOException,
     138            com.sshtools.j2ssh.transport.InvalidMessageException {
     139        try {
     140            operation = bar.readString();
     141            pubkey = SshKeyPairFactory.decodePublicKey(bar.readBinaryString());
     142            data = new byte[bar.available()];
     143            bar.read(data);
     144        } catch (IOException ex) {
     145            throw new InvalidMessageException(ex.getMessage());
     146        }
     147    }
     148}
  • source/com/sshtools/j2ssh/agent/KeyConstraints.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.io.UnsignedInteger32;
     32
     33import java.io.IOException;
     34
     35
     36/**
     37 *
     38 *
     39 * @author $author$
     40 * @version $Revision: 1.12 $
     41 */
     42public class KeyConstraints {
     43    /**  */
     44    public static final long NO_TIMEOUT = 0;
     45
     46    /**  */
     47    public static final long NO_LIMIT = 0xffffffffL;
     48
     49    /**  */
     50    protected static final int SSH_AGENT_CONSTRAINT_TIMEOUT = 50;
     51
     52    /**  */
     53    protected static final int SSH_AGENT_CONSTRAINT_USE_LIMIT = 51;
     54
     55    /**  */
     56    protected static final int SSH_AGENT_CONSTRAINT_FORWARDING_STEPS = 52;
     57
     58    /**  */
     59    protected static final int SSH_AGENT_CONSTRAINT_FORWARDING_PATH = 100;
     60
     61    /**  */
     62    protected static final int SSH_AGENT_CONSTRAINT_SSH1_COMPAT = 150;
     63
     64    /**  */
     65    protected static final int SSH_AGENT_CONSTRAINT_NEED_USER_VERIFICATION = 151;
     66    private UnsignedInteger32 timeout = new UnsignedInteger32(NO_TIMEOUT);
     67    private UnsignedInteger32 uselimit = new UnsignedInteger32(NO_LIMIT);
     68    private UnsignedInteger32 maxsteps = new UnsignedInteger32(NO_LIMIT);
     69    private String forwardingpath = "";
     70    private boolean userverify = false;
     71    private boolean compat = false;
     72    private long keyadded = System.currentTimeMillis();
     73    private long usedcount = 0;
     74
     75    /**
     76     * Creates a new KeyConstraints object.
     77     */
     78    public KeyConstraints() {
     79    }
     80
     81    /**
     82     * Creates a new KeyConstraints object.
     83     *
     84     * @param bar
     85     *
     86     * @throws IOException
     87     */
     88    public KeyConstraints(ByteArrayReader bar) throws IOException {
     89        while (bar.available() > 0) {
     90            switch (bar.read() & 0xFF) {
     91            case SSH_AGENT_CONSTRAINT_TIMEOUT:
     92                timeout = bar.readUINT32();
     93
     94                break;
     95
     96            case SSH_AGENT_CONSTRAINT_USE_LIMIT:
     97                uselimit = bar.readUINT32();
     98
     99                break;
     100
     101            case SSH_AGENT_CONSTRAINT_FORWARDING_STEPS:
     102                maxsteps = bar.readUINT32();
     103
     104                break;
     105
     106            case SSH_AGENT_CONSTRAINT_FORWARDING_PATH:
     107                forwardingpath = bar.readString();
     108
     109                break;
     110
     111            case SSH_AGENT_CONSTRAINT_SSH1_COMPAT:
     112                compat = (bar.read() != 0);
     113
     114                break;
     115
     116            case SSH_AGENT_CONSTRAINT_NEED_USER_VERIFICATION:
     117                userverify = (bar.read() != 0);
     118
     119                break;
     120            }
     121        }
     122    }
     123
     124    /**
     125     *
     126     *
     127     * @param timeout
     128     */
     129    public void setKeyTimeout(UnsignedInteger32 timeout) {
     130        this.timeout = timeout;
     131    }
     132
     133    /**
     134     *
     135     *
     136     * @param uselimit
     137     */
     138    public void setKeyUseLimit(int uselimit) {
     139        this.uselimit = new UnsignedInteger32(uselimit);
     140    }
     141
     142    /**
     143     *
     144     *
     145     * @param maxsteps
     146     */
     147    public void setMaximumForwardingSteps(int maxsteps) {
     148        this.maxsteps = new UnsignedInteger32(maxsteps);
     149    }
     150
     151    /**
     152     *
     153     *
     154     * @param forwardingpath
     155     */
     156    public void setForwardingPath(String forwardingpath) {
     157        this.forwardingpath = forwardingpath;
     158    }
     159
     160    /**
     161     *
     162     *
     163     * @param userverify
     164     */
     165    public void setRequiresUserVerification(boolean userverify) {
     166        this.userverify = userverify;
     167    }
     168
     169    /**
     170     *
     171     *
     172     * @param compat
     173     */
     174    public void setSSH1Compatible(boolean compat) {
     175        this.compat = compat;
     176    }
     177
     178    /**
     179     *
     180     *
     181     * @return
     182     */
     183    public long getKeyTimeout() {
     184        return timeout.longValue();
     185    }
     186
     187    /**
     188     *
     189     *
     190     * @return
     191     */
     192    public long getKeyUseLimit() {
     193        return uselimit.longValue();
     194    }
     195
     196    /**
     197     *
     198     *
     199     * @return
     200     */
     201    public long getMaximumForwardingSteps() {
     202        return maxsteps.longValue();
     203    }
     204
     205    /**
     206     *
     207     *
     208     * @return
     209     */
     210    public long getUsedCount() {
     211        return usedcount;
     212    }
     213
     214    /**
     215     *
     216     *
     217     * @return
     218     */
     219    public boolean hasTimedOut() {
     220        return (timeout.longValue() != 0)
     221        ? (((System.currentTimeMillis() - keyadded) / 1000) > timeout.longValue())
     222        : false;
     223    }
     224
     225    /**
     226     *
     227     *
     228     * @return
     229     */
     230    public boolean canUse() {
     231        return (uselimit.longValue() != 0) ? (usedcount < uselimit.longValue())
     232                                           : true;
     233    }
     234
     235    /**
     236     *
     237     */
     238    public void use() {
     239        usedcount++;
     240    }
     241
     242    /**
     243     *
     244     *
     245     * @return
     246     */
     247    public String getForwardingPath() {
     248        return forwardingpath;
     249    }
     250
     251    /**
     252     *
     253     *
     254     * @return
     255     */
     256    public boolean requiresUserVerification() {
     257        return userverify;
     258    }
     259
     260    /**
     261     *
     262     *
     263     * @return
     264     */
     265    public boolean isSSH1Compatible() {
     266        return compat;
     267    }
     268
     269    /**
     270     *
     271     *
     272     * @return
     273     *
     274     * @throws IOException
     275     */
     276    public byte[] toByteArray() throws IOException {
     277        ByteArrayWriter baw = new ByteArrayWriter();
     278        baw.write(SSH_AGENT_CONSTRAINT_TIMEOUT);
     279        baw.writeUINT32(timeout);
     280        baw.write(SSH_AGENT_CONSTRAINT_USE_LIMIT);
     281        baw.writeUINT32(uselimit);
     282        baw.write(SSH_AGENT_CONSTRAINT_FORWARDING_STEPS);
     283        baw.writeUINT32(maxsteps);
     284        baw.write(SSH_AGENT_CONSTRAINT_FORWARDING_PATH);
     285        baw.writeString(forwardingpath);
     286        baw.write(SSH_AGENT_CONSTRAINT_SSH1_COMPAT);
     287        baw.write(compat ? 0 : 1);
     288        baw.write(SSH_AGENT_CONSTRAINT_NEED_USER_VERIFICATION);
     289        baw.write(userverify ? 0 : 1);
     290
     291        return baw.toByteArray();
     292    }
     293}
  • source/com/sshtools/j2ssh/agent/SshAgentKeyList.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32import com.sshtools.j2ssh.transport.InvalidMessageException;
     33import com.sshtools.j2ssh.transport.publickey.SshKeyPairFactory;
     34import com.sshtools.j2ssh.transport.publickey.SshPublicKey;
     35
     36import java.io.IOException;
     37
     38import java.util.HashMap;
     39import java.util.Iterator;
     40import java.util.Map;
     41
     42
     43class SshAgentKeyList extends SubsystemMessage {
     44    /**  */
     45    public static final int SSH_AGENT_KEY_LIST = 104;
     46    private Map keys;
     47
     48    /**
     49     * Creates a new SshAgentKeyList object.
     50     *
     51     * @param keys
     52     */
     53    public SshAgentKeyList(Map keys) {
     54        super(SSH_AGENT_KEY_LIST);
     55        this.keys = keys;
     56    }
     57
     58    /**
     59     * Creates a new SshAgentKeyList object.
     60     */
     61    public SshAgentKeyList() {
     62        super(SSH_AGENT_KEY_LIST);
     63        this.keys = new HashMap();
     64    }
     65
     66    /**
     67     *
     68     *
     69     * @return
     70     */
     71    public Map getKeys() {
     72        return keys;
     73    }
     74
     75    /**
     76     *
     77     *
     78     * @return
     79     */
     80    public String getMessageName() {
     81        return "SSH_AGENT_KEY_LIST";
     82    }
     83
     84    /**
     85     *
     86     *
     87     * @param baw
     88     *
     89     * @throws java.io.IOException
     90     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     91     *         ME!
     92     * @throws InvalidMessageException
     93     */
     94    public void constructByteArray(ByteArrayWriter baw)
     95        throws java.io.IOException,
     96            com.sshtools.j2ssh.transport.InvalidMessageException {
     97        try {
     98            baw.writeInt(keys.size());
     99
     100            Map.Entry entry;
     101            Iterator it = keys.entrySet().iterator();
     102            SshPublicKey key;
     103            String description;
     104
     105            while (it.hasNext()) {
     106                entry = (Map.Entry) it.next();
     107                key = (SshPublicKey) entry.getKey();
     108                description = (String) entry.getValue();
     109                baw.writeBinaryString(key.getEncoded());
     110                baw.writeString(description);
     111            }
     112        } catch (IOException ex) {
     113            throw new InvalidMessageException("Failed to write message data");
     114        }
     115    }
     116
     117    /**
     118     *
     119     *
     120     * @param bar
     121     *
     122     * @throws java.io.IOException
     123     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     124     *         ME!
     125     * @throws InvalidMessageException
     126     */
     127    public void constructMessage(ByteArrayReader bar)
     128        throws java.io.IOException,
     129            com.sshtools.j2ssh.transport.InvalidMessageException {
     130        try {
     131            int num = (int) bar.readInt();
     132            SshPublicKey key;
     133            String description;
     134            byte[] buf;
     135
     136            for (int i = 0; i < num; i++) {
     137                buf = bar.readBinaryString();
     138                key = SshKeyPairFactory.decodePublicKey(buf);
     139                description = bar.readString();
     140                keys.put(key, description);
     141            }
     142        } catch (IOException ex) {
     143            throw new InvalidMessageException("Failed to read message data");
     144        }
     145    }
     146}
  • source/com/sshtools/j2ssh/agent/SshAgentFailure.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32import com.sshtools.j2ssh.transport.InvalidMessageException;
     33
     34import java.io.IOException;
     35
     36
     37class SshAgentFailure extends SubsystemMessage {
     38    /**  */
     39    public static final int SSH_AGENT_FAILURE = 5;
     40
     41    /**  */
     42    public static final int SSH_AGENT_ERROR_TIMEOUT = 1;
     43
     44    /**  */
     45    public static final int SSH_AGENT_ERROR_KEY_NOT_FOUND = 2;
     46
     47    /**  */
     48    public static final int SSH_AGENT_ERROR_DECRYPT_FAILED = 3;
     49
     50    /**  */
     51    public static final int SSH_AGENT_ERROR_SIZE_ERROR = 4;
     52
     53    /**  */
     54    public static final int SSH_AGENT_ERROR_KEY_NOT_SUITABLE = 5;
     55
     56    /**  */
     57    public static final int SSH_AGENT_ERROR_DENIED = 6;
     58
     59    /**  */
     60    public static final int SSH_AGENT_ERROR_FAILURE = 7;
     61
     62    /**  */
     63    public static final int SSH_AGENT_ERROR_UNSUPPORTED_OP = 8;
     64    private int errorcode;
     65
     66    /**
     67     * Creates a new SshAgentFailure object.
     68     */
     69    public SshAgentFailure() {
     70        super(SSH_AGENT_FAILURE);
     71    }
     72
     73    /**
     74     * Creates a new SshAgentFailure object.
     75     *
     76     * @param errorcode
     77     */
     78    public SshAgentFailure(int errorcode) {
     79        super(SSH_AGENT_FAILURE);
     80        this.errorcode = errorcode;
     81    }
     82
     83    /**
     84     *
     85     *
     86     * @return
     87     */
     88    public String getMessageName() {
     89        return "SSH_AGENT_FAILURE";
     90    }
     91
     92    /**
     93     *
     94     *
     95     * @return
     96     */
     97    public int getErrorCode() {
     98        return errorcode;
     99    }
     100
     101    /**
     102     *
     103     *
     104     * @param baw
     105     *
     106     * @throws java.io.IOException
     107     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     108     *         ME!
     109     * @throws InvalidMessageException
     110     */
     111    public void constructByteArray(ByteArrayWriter baw)
     112        throws java.io.IOException,
     113            com.sshtools.j2ssh.transport.InvalidMessageException {
     114        try {
     115            baw.writeInt(errorcode);
     116        } catch (IOException ioe) {
     117            throw new InvalidMessageException(ioe.getMessage());
     118        }
     119    }
     120
     121    /**
     122     *
     123     *
     124     * @param bar
     125     *
     126     * @throws java.io.IOException
     127     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     128     *         ME!
     129     * @throws InvalidMessageException
     130     */
     131    public void constructMessage(ByteArrayReader bar)
     132        throws java.io.IOException,
     133            com.sshtools.j2ssh.transport.InvalidMessageException {
     134        try {
     135            errorcode = (int) bar.readInt();
     136        } catch (IOException ioe) {
     137            throw new InvalidMessageException(ioe.getMessage());
     138        }
     139    }
     140}
  • source/com/sshtools/j2ssh/agent/SshAgentDeleteAllKeys.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32
     33
     34class SshAgentDeleteAllKeys extends SubsystemMessage {
     35    /**  */
     36    public static final int SSH_AGENT_DELETE_ALL_KEYS = 203;
     37
     38    /**
     39     * Creates a new SshAgentDeleteAllKeys object.
     40     */
     41    public SshAgentDeleteAllKeys() {
     42        super(SSH_AGENT_DELETE_ALL_KEYS);
     43    }
     44
     45    /**
     46     *
     47     *
     48     * @return
     49     */
     50    public String getMessageName() {
     51        return "SSH_AGENT_DELETE_ALL_KEYS";
     52    }
     53
     54    /**
     55     *
     56     *
     57     * @param baw
     58     *
     59     * @throws java.io.IOException
     60     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     61     *         ME!
     62     */
     63    public void constructByteArray(ByteArrayWriter baw)
     64        throws java.io.IOException,
     65            com.sshtools.j2ssh.transport.InvalidMessageException {
     66    }
     67
     68    /**
     69     *
     70     *
     71     * @param bar
     72     *
     73     * @throws java.io.IOException
     74     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     75     *         ME!
     76     */
     77    public void constructMessage(ByteArrayReader bar)
     78        throws java.io.IOException,
     79            com.sshtools.j2ssh.transport.InvalidMessageException {
     80    }
     81}
  • source/com/sshtools/j2ssh/agent/SshAgentLock.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32import com.sshtools.j2ssh.transport.InvalidMessageException;
     33
     34import java.io.IOException;
     35
     36
     37class SshAgentLock extends SubsystemMessage {
     38    /**  */
     39    public static final int SSH_AGENT_LOCK = 208;
     40    String password;
     41
     42    /**
     43     * Creates a new SshAgentLock object.
     44     */
     45    public SshAgentLock() {
     46        super(SSH_AGENT_LOCK);
     47    }
     48
     49    /**
     50     * Creates a new SshAgentLock object.
     51     *
     52     * @param password
     53     */
     54    public SshAgentLock(String password) {
     55        super(SSH_AGENT_LOCK);
     56        this.password = password;
     57    }
     58
     59    /**
     60     *
     61     *
     62     * @return
     63     */
     64    public String getPassword() {
     65        return password;
     66    }
     67
     68    /**
     69     *
     70     *
     71     * @return
     72     */
     73    public String getMessageName() {
     74        return "SSH_AGENT_LOCK";
     75    }
     76
     77    /**
     78     *
     79     *
     80     * @param baw
     81     *
     82     * @throws java.io.IOException
     83     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     84     *         ME!
     85     * @throws InvalidMessageException
     86     */
     87    public void constructByteArray(ByteArrayWriter baw)
     88        throws java.io.IOException,
     89            com.sshtools.j2ssh.transport.InvalidMessageException {
     90        try {
     91            baw.writeString(password);
     92        } catch (IOException ioe) {
     93            throw new InvalidMessageException(ioe.getMessage());
     94        }
     95    }
     96
     97    /**
     98     *
     99     *
     100     * @param bar
     101     *
     102     * @throws java.io.IOException
     103     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     104     *         ME!
     105     * @throws InvalidMessageException
     106     */
     107    public void constructMessage(ByteArrayReader bar)
     108        throws java.io.IOException,
     109            com.sshtools.j2ssh.transport.InvalidMessageException {
     110        try {
     111            password = bar.readString();
     112        } catch (IOException ioe) {
     113            throw new InvalidMessageException(ioe.getMessage());
     114        }
     115    }
     116}
  • source/com/sshtools/j2ssh/agent/SshAgentOperationComplete.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32
     33import java.io.IOException;
     34
     35
     36class SshAgentOperationComplete extends SubsystemMessage {
     37    /**  */
     38    public static final int SSH_AGENT_OPERATION_COMPLETE = 105;
     39    private byte[] data;
     40
     41    /**
     42     * Creates a new SshAgentOperationComplete object.
     43     */
     44    public SshAgentOperationComplete() {
     45        super(SSH_AGENT_OPERATION_COMPLETE);
     46    }
     47
     48    /**
     49     * Creates a new SshAgentOperationComplete object.
     50     *
     51     * @param data
     52     */
     53    public SshAgentOperationComplete(byte[] data) {
     54        super(SSH_AGENT_OPERATION_COMPLETE);
     55        this.data = data;
     56    }
     57
     58    /**
     59     *
     60     *
     61     * @return
     62     */
     63    public byte[] getData() {
     64        return data;
     65    }
     66
     67    /**
     68     *
     69     *
     70     * @return
     71     */
     72    public String getMessageName() {
     73        return "SSH_AGENT_OPERATION_COMPLETE";
     74    }
     75
     76    /**
     77     *
     78     *
     79     * @param baw
     80     *
     81     * @throws java.io.IOException
     82     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     83     *         ME!
     84     */
     85    public void constructByteArray(ByteArrayWriter baw)
     86        throws java.io.IOException,
     87            com.sshtools.j2ssh.transport.InvalidMessageException {
     88        try {
     89            baw.writeBinaryString(data);
     90        } catch (IOException ioe) {
     91        }
     92    }
     93
     94    /**
     95     *
     96     *
     97     * @param bar
     98     *
     99     * @throws java.io.IOException
     100     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     101     *         ME!
     102     */
     103    public void constructMessage(ByteArrayReader bar)
     104        throws java.io.IOException,
     105            com.sshtools.j2ssh.transport.InvalidMessageException {
     106        try {
     107            data = bar.readBinaryString();
     108        } catch (IOException ioe) {
     109        }
     110    }
     111}
  • source/com/sshtools/j2ssh/agent/SshAgentUnlock.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32import com.sshtools.j2ssh.transport.InvalidMessageException;
     33
     34import java.io.IOException;
     35
     36
     37class SshAgentUnlock extends SubsystemMessage {
     38    /**  */
     39    public static final int SSH_AGENT_UNLOCK = 209;
     40    String password;
     41
     42    /**
     43     * Creates a new SshAgentUnlock object.
     44     */
     45    public SshAgentUnlock() {
     46        super(SSH_AGENT_UNLOCK);
     47    }
     48
     49    /**
     50     * Creates a new SshAgentUnlock object.
     51     *
     52     * @param password
     53     */
     54    public SshAgentUnlock(String password) {
     55        super(SSH_AGENT_UNLOCK);
     56        this.password = password;
     57    }
     58
     59    /**
     60     *
     61     *
     62     * @return
     63     */
     64    public String getPassword() {
     65        return password;
     66    }
     67
     68    /**
     69     *
     70     *
     71     * @return
     72     */
     73    public String getMessageName() {
     74        return "SSH_AGENT_UNLOCK";
     75    }
     76
     77    /**
     78     *
     79     *
     80     * @param baw
     81     *
     82     * @throws java.io.IOException
     83     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     84     *         ME!
     85     * @throws InvalidMessageException
     86     */
     87    public void constructByteArray(ByteArrayWriter baw)
     88        throws java.io.IOException,
     89            com.sshtools.j2ssh.transport.InvalidMessageException {
     90        try {
     91            baw.writeString(password);
     92        } catch (IOException ioe) {
     93            throw new InvalidMessageException(ioe.getMessage());
     94        }
     95    }
     96
     97    /**
     98     *
     99     *
     100     * @param bar
     101     *
     102     * @throws java.io.IOException
     103     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     104     *         ME!
     105     * @throws InvalidMessageException
     106     */
     107    public void constructMessage(ByteArrayReader bar)
     108        throws java.io.IOException,
     109            com.sshtools.j2ssh.transport.InvalidMessageException {
     110        try {
     111            password = bar.readString();
     112        } catch (IOException ioe) {
     113            throw new InvalidMessageException(ioe.getMessage());
     114        }
     115    }
     116}
  • source/com/sshtools/j2ssh/agent/SshAgentPing.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32import com.sshtools.j2ssh.transport.InvalidMessageException;
     33
     34import java.io.IOException;
     35
     36
     37class SshAgentPing extends SubsystemMessage {
     38    /**  */
     39    public static final int SSH_AGENT_PING = 212;
     40    private byte[] padding;
     41
     42    /**
     43     * Creates a new SshAgentPing object.
     44     */
     45    public SshAgentPing() {
     46        super(SSH_AGENT_PING);
     47    }
     48
     49    /**
     50     * Creates a new SshAgentPing object.
     51     *
     52     * @param padding
     53     */
     54    public SshAgentPing(byte[] padding) {
     55        super(SSH_AGENT_PING);
     56        this.padding = padding;
     57    }
     58
     59    /**
     60     *
     61     *
     62     * @return
     63     */
     64    public byte[] getPadding() {
     65        return padding;
     66    }
     67
     68    /**
     69     *
     70     *
     71     * @return
     72     */
     73    public String getMessageName() {
     74        return "SSH_AGENT_PING";
     75    }
     76
     77    /**
     78     *
     79     *
     80     * @param baw
     81     *
     82     * @throws java.io.IOException
     83     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     84     *         ME!
     85     * @throws InvalidMessageException
     86     */
     87    public void constructByteArray(ByteArrayWriter baw)
     88        throws java.io.IOException,
     89            com.sshtools.j2ssh.transport.InvalidMessageException {
     90        try {
     91            baw.write(padding);
     92        } catch (IOException ioe) {
     93            throw new InvalidMessageException(ioe.getMessage());
     94        }
     95    }
     96
     97    /**
     98     *
     99     *
     100     * @param bar
     101     *
     102     * @throws java.io.IOException
     103     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     104     *         ME!
     105     * @throws InvalidMessageException
     106     */
     107    public void constructMessage(ByteArrayReader bar)
     108        throws java.io.IOException,
     109            com.sshtools.j2ssh.transport.InvalidMessageException {
     110        try {
     111            padding = new byte[bar.available()];
     112            bar.read(padding);
     113        } catch (IOException ioe) {
     114            throw new InvalidMessageException(ioe.getMessage());
     115        }
     116    }
     117}
  • source/com/sshtools/j2ssh/agent/SshAgentRequestVersion.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32import com.sshtools.j2ssh.transport.InvalidMessageException;
     33
     34import java.io.IOException;
     35
     36
     37class SshAgentRequestVersion extends SubsystemMessage {
     38    /**  */
     39    public static final int SSH_AGENT_REQUEST_VERSION = 1;
     40    String version;
     41
     42    /**
     43     * Creates a new SshAgentRequestVersion object.
     44     */
     45    public SshAgentRequestVersion() {
     46        super(SSH_AGENT_REQUEST_VERSION);
     47    }
     48
     49    /**
     50     * Creates a new SshAgentRequestVersion object.
     51     *
     52     * @param version
     53     */
     54    public SshAgentRequestVersion(String version) {
     55        super(SSH_AGENT_REQUEST_VERSION);
     56        this.version = version;
     57    }
     58
     59    /**
     60     *
     61     *
     62     * @return
     63     */
     64    public String getVersion() {
     65        return version;
     66    }
     67
     68    /**
     69     *
     70     *
     71     * @return
     72     */
     73    public String getMessageName() {
     74        return "SSH_AGENT_REQUEST_VERSION";
     75    }
     76
     77    /**
     78     *
     79     *
     80     * @param baw
     81     *
     82     * @throws java.io.IOException
     83     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     84     *         ME!
     85     * @throws InvalidMessageException
     86     */
     87    public void constructByteArray(ByteArrayWriter baw)
     88        throws java.io.IOException,
     89            com.sshtools.j2ssh.transport.InvalidMessageException {
     90        try {
     91            baw.writeString(version);
     92        } catch (IOException ex) {
     93            throw new InvalidMessageException(ex.getMessage());
     94        }
     95    }
     96
     97    /**
     98     *
     99     *
     100     * @param bar
     101     *
     102     * @throws java.io.IOException
     103     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     104     *         ME!
     105     * @throws InvalidMessageException
     106     */
     107    public void constructMessage(ByteArrayReader bar)
     108        throws java.io.IOException,
     109            com.sshtools.j2ssh.transport.InvalidMessageException {
     110        try {
     111            version = bar.readString();
     112        } catch (IOException ex) {
     113            throw new InvalidMessageException(ex.getMessage());
     114        }
     115    }
     116}
  • source/com/sshtools/j2ssh/agent/SshAgentSocketListener.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.util.StartStopState;
     30
     31import org.apache.log4j.Logger;
     32
     33import java.io.IOException;
     34
     35import java.net.InetAddress;
     36import java.net.ServerSocket;
     37import java.net.Socket;
     38
     39
     40/**
     41 *
     42 *
     43 * @author $author$
     44 * @version $Revision: 1.20 $
     45 */
     46public class SshAgentSocketListener {
     47    private static Logger log = Logger.getLogger(SshAgentSocketListener.class);
     48    StartStopState state = new StartStopState(StartStopState.STOPPED);
     49    KeyStore keystore;
     50    ServerSocket server;
     51    int port;
     52    Thread thread;
     53    String location;
     54
     55    /**
     56     * Creates a new SshAgentSocketListener object.
     57     *
     58     * @param location the location of the listening agent. This should be a
     59     *        random port on the localhost such as localhost:15342
     60     * @param keystore the keystore for agent operation
     61     *
     62     * @throws AgentNotAvailableException if the location specifies an invalid
     63     *         location
     64     */
     65    public SshAgentSocketListener(String location, KeyStore keystore)
     66        throws AgentNotAvailableException {
     67        log.info("New SshAgent instance created");
     68
     69        // Verify the agent location
     70        this.location = location;
     71
     72        if (location == null) {
     73            throw new AgentNotAvailableException();
     74        }
     75
     76        this.location = location;
     77
     78        int idx = location.indexOf(":");
     79
     80        if (idx == -1) {
     81            throw new AgentNotAvailableException();
     82        }
     83
     84        String host = location.substring(0, idx);
     85        port = Integer.parseInt(location.substring(idx + 1));
     86        this.keystore = keystore;
     87
     88        try {
     89            server = new ServerSocket(port, 5, InetAddress.getByName(host));
     90        } catch (Exception e) {
     91            e.printStackTrace();
     92        }
     93    }
     94
     95    /**
     96     * Get the agent listeners state
     97     *
     98     * @return the current state of the listener
     99     */
     100    public StartStopState getState() {
     101        return state;
     102    }
     103
     104    /**
     105     * Starts the agent listener thread
     106     */
     107    public void start() {
     108        thread = new Thread(new Runnable() {
     109                    public void run() {
     110                        try {
     111                            Socket socket;
     112                            System.setProperty("sshtools.agent", location);
     113                            state.setValue(StartStopState.STARTED);
     114
     115                            while ((socket = server.accept()) != null) {
     116                                SshAgentConnection agentClient = new SshAgentConnection(keystore,
     117                                        socket.getInputStream(),
     118                                        socket.getOutputStream());
     119                            }
     120
     121                            thread = null;
     122                        } catch (IOException ex) {
     123                            log.info("The agent listener closed: " +
     124                                ex.getMessage());
     125                        } finally {
     126                            state.setValue(StartStopState.STOPPED);
     127                        }
     128                    }
     129                });
     130        thread.start();
     131    }
     132
     133    /**
     134     * The current port of the agent listener
     135     *
     136     * @return the integer port
     137     */
     138    public int getPort() {
     139        return port;
     140    }
     141
     142    /**
     143     * Stops the agent listener
     144     */
     145    public void stop() {
     146        try {
     147            server.close();
     148        } catch (IOException ex) {
     149        }
     150    }
     151
     152    /**
     153     * Gets the underlying keystore for this agent listener.
     154     *
     155     * @return the keystore
     156     */
     157    protected KeyStore getKeystore() {
     158        return keystore;
     159    }
     160
     161    /**
     162     * Configure a new random port for the agent listener.
     163     *
     164     * @return the random port for this agent.
     165     */
     166    public static int configureNewLocation() {
     167        return 49152 + (int) Math.round(((float) 16383 * Math.random()));
     168    }
     169
     170    /**
     171     * The main entry point for the application. This method currently accepts
     172     * the -start parameter which will look for the sshtools.agent system
     173     * property. To configure the agent and to get a valid location call with
     174     * -configure, set the system sshtools.home system property and start.
     175     *
     176     * @param args the programs arguments
     177     */
     178    public static void main(String[] args) {
     179        if (args.length > 0) {
     180            if (args[0].equals("-start")) {
     181                Thread thread = new Thread(new Runnable() {
     182                            public void run() {
     183                                try {
     184                                    SshAgentSocketListener agent = new SshAgentSocketListener(System.getProperty(
     185                                                "sshtools.agent"),
     186                                            new KeyStore());
     187                                    agent.start();
     188                                } catch (Exception ex) {
     189                                    ex.printStackTrace();
     190                                }
     191                            }
     192                        });
     193                thread.start();
     194            }
     195
     196            if (args[0].equals("-configure")) {
     197                System.out.println("SET SSHTOOLS_AGENT=localhost:" +
     198                    String.valueOf(configureNewLocation()));
     199            }
     200        }
     201    }
     202}
  • source/com/sshtools/j2ssh/agent/SshAgentConnection.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.configuration.*;
     30import com.sshtools.j2ssh.io.*;
     31import com.sshtools.j2ssh.subsystem.*;
     32import com.sshtools.j2ssh.transport.publickey.*;
     33
     34import org.apache.log4j.Logger;
     35
     36import java.io.*;
     37
     38import java.net.*;
     39
     40import java.util.*;
     41
     42
     43/**
     44 * This class provides a connection using the SSH agent protocol.
     45 *
     46 * @author $author$
     47 * @version $Revision: 1.14 $
     48 */
     49public class SshAgentConnection implements Runnable {
     50    private static Logger log = Logger.getLogger(SshAgentConnection.class);
     51    InputStream in;
     52    OutputStream out;
     53    KeyStore keystore;
     54    Thread thread;
     55    Vector forwardingNodes = new Vector();
     56    Socket socket;
     57
     58    SshAgentConnection(KeyStore keystore, InputStream in, OutputStream out) {
     59        this.keystore = keystore;
     60        this.in = in;
     61        this.out = out;
     62        thread = new Thread(this);
     63        thread.start();
     64    }
     65
     66    SshAgentConnection(KeyStore keystore, Socket socket)
     67        throws IOException {
     68        this.keystore = keystore;
     69        this.in = socket.getInputStream();
     70        this.out = socket.getOutputStream();
     71        this.socket = socket;
     72        socket.setSoTimeout(5000);
     73        thread = new Thread(this);
     74        thread.start();
     75    }
     76
     77    /**
     78     * Send a success message.
     79     *
     80     * @throws IOException if an IO error occurs
     81     */
     82    protected void sendAgentSuccess() throws IOException {
     83        SshAgentSuccess msg = new SshAgentSuccess();
     84        sendMessage(msg);
     85    }
     86
     87    /**
     88     * Send a failure message
     89     *
     90     * @param errorcode the error code of the failure
     91     *
     92     * @throws IOException if an IO error occurs
     93     */
     94    protected void sendAgentFailure(int errorcode) throws IOException {
     95        SshAgentFailure msg = new SshAgentFailure(errorcode);
     96        sendMessage(msg);
     97    }
     98
     99    /**
     100     * Send the version response; this class currently implements version 2
     101     *
     102     * @throws IOException if an IO error occurs
     103     */
     104    protected void sendVersionResponse() throws IOException {
     105        SshAgentVersionResponse msg = new SshAgentVersionResponse(2);
     106        sendMessage(msg);
     107    }
     108
     109    /**
     110     * Send the agents key list to the remote side. This supplies all the
     111     * public keys.
     112     *
     113     * @throws IOException if an IO error occurs
     114     */
     115    protected void sendAgentKeyList() throws IOException {
     116        SshAgentKeyList msg = new SshAgentKeyList(keystore.getPublicKeys());
     117        sendMessage(msg);
     118    }
     119
     120    /**
     121     * Send the completed signing operation data.
     122     *
     123     * @param data the data generating from the signing operation
     124     *
     125     * @throws IOException if an IO error occurs
     126     */
     127    protected void sendOperationComplete(byte[] data) throws IOException {
     128        SshAgentOperationComplete msg = new SshAgentOperationComplete(data);
     129        sendMessage(msg);
     130    }
     131
     132    /**
     133     * Send some random data to the remote side.
     134     *
     135     * @param data some random data
     136     *
     137     * @throws IOException if an IO error occurs
     138     */
     139    protected void sendRandomData(byte[] data) throws IOException {
     140        SshAgentRandomData msg = new SshAgentRandomData(data);
     141        sendMessage(msg);
     142    }
     143
     144    /**
     145     * Send the agent alive message. This is sent to test whether the agent is
     146     * still active
     147     *
     148     * @param padding some random padding for the message
     149     *
     150     * @throws IOException if an IO error occurs
     151     */
     152    protected void sendAgentAlive(byte[] padding) throws IOException {
     153        SshAgentAlive msg = new SshAgentAlive(padding);
     154        sendMessage(msg);
     155    }
     156
     157    /**
     158     * Sends a subsystem message.
     159     *
     160     * @param msg the subsystem message to send
     161     *
     162     * @throws IOException if an IO error occurs
     163     */
     164    protected void sendMessage(SubsystemMessage msg) throws IOException {
     165        log.info("Sending message " + msg.getMessageName());
     166               
     167                ByteArrayWriter bow = new ByteArrayWriter();
     168                msg.constructByteArray(bow);
     169        byte[] msgdata = bow.toByteArray();
     170        out.write(ByteArrayWriter.encodeInt(msgdata.length));
     171        out.write(msgdata);
     172        out.flush();
     173    }
     174
     175    /**
     176     * Called when a forwarding notice is recceived from the remote side.
     177     *
     178     * @param msg the forwarding notice
     179     */
     180    protected void onForwardingNotice(SshAgentForwardingNotice msg) {
     181        forwardingNodes.add(new ForwardingNotice(msg.getRemoteHostname(),
     182                msg.getRemoteIPAddress(), msg.getRemotePort()));
     183    }
     184
     185    /**
     186     * Called when the remote side requests the version number of this
     187     * protocol.
     188     *
     189     * @param msg the version request message
     190     *
     191     * @throws IOException if an IO error occurs
     192     */
     193    protected void onRequestVersion(SshAgentRequestVersion msg)
     194        throws IOException {
     195        sendVersionResponse();
     196    }
     197
     198    /**
     199     * Called when the remote side adds a key the agent.
     200     *
     201     * @param msg the message containing the key
     202     *
     203     * @throws IOException if an IO error occurs
     204     */
     205    protected void onAddKey(SshAgentAddKey msg) throws IOException {
     206        if (keystore.addKey(msg.getPrivateKey(), msg.getPublicKey(),
     207                    msg.getDescription(), msg.getKeyConstraints())) {
     208            sendAgentSuccess();
     209        } else {
     210            sendAgentFailure(SshAgentFailure.SSH_AGENT_ERROR_FAILURE);
     211        }
     212    }
     213
     214    /**
     215     * Called when the remote side requests that all keys be removed from the
     216     * agent.
     217     *
     218     * @param msg the delete all keys message
     219     *
     220     * @throws IOException if an IO error occurs
     221     */
     222    protected void onDeleteAllKeys(SshAgentDeleteAllKeys msg)
     223        throws IOException {
     224        keystore.deleteAllKeys();
     225        sendAgentSuccess();
     226    }
     227
     228    /**
     229     * Called by the remote side when a list of the agents keys is required
     230     *
     231     * @param msg the list all keys message
     232     *
     233     * @throws IOException if an IO error occurs
     234     */
     235    protected void onListKeys(SshAgentListKeys msg) throws IOException {
     236        sendAgentKeyList();
     237    }
     238
     239    /**
     240     * Called by the remote side to initiate a private key operation.
     241     *
     242     * @param msg the private key operation message
     243     *
     244     * @throws IOException if an IO error occurs
     245     */
     246    protected void onPrivateKeyOp(SshAgentPrivateKeyOp msg)
     247        throws IOException {
     248        try {
     249            if (msg.getOperation().equals("sign")) {
     250                sendAgentFailure(SshAgentFailure.SSH_AGENT_ERROR_KEY_NOT_SUITABLE);
     251            } else if (msg.getOperation().equals("hash-and-sign")) {
     252                byte[] sig = keystore.performHashAndSign(msg.getPublicKey(),
     253                        forwardingNodes, msg.getOperationData());
     254                sendOperationComplete(sig);
     255            } else if (msg.getOperation().equals("decrypt")) {
     256                sendAgentFailure(SshAgentFailure.SSH_AGENT_ERROR_KEY_NOT_SUITABLE);
     257            } else if (msg.getOperation().equals("ssh1-challenge-response")) {
     258                sendAgentFailure(SshAgentFailure.SSH_AGENT_ERROR_KEY_NOT_SUITABLE);
     259            } else {
     260                sendAgentFailure(SshAgentFailure.SSH_AGENT_ERROR_UNSUPPORTED_OP);
     261            }
     262        } catch (KeyTimeoutException ex) {
     263            sendAgentFailure(SshAgentFailure.SSH_AGENT_ERROR_TIMEOUT);
     264        } catch (InvalidSshKeyException ex) {
     265            sendAgentFailure(SshAgentFailure.SSH_AGENT_ERROR_KEY_NOT_FOUND);
     266        }
     267    }
     268
     269    /**
     270     * Called by the remote side to delete a key from the agent
     271     *
     272     * @param msg the message containin the key to delete
     273     *
     274     * @throws IOException if an IO error occurs
     275     */
     276    protected void onDeleteKey(SshAgentDeleteKey msg) throws IOException {
     277        if (keystore.deleteKey(msg.getPublicKey(), msg.getDescription())) {
     278            sendAgentSuccess();
     279        } else {
     280            sendAgentFailure(SshAgentFailure.SSH_AGENT_ERROR_KEY_NOT_FOUND);
     281        }
     282    }
     283
     284    /**
     285     * Called by the remote side when the agent is to be locked
     286     *
     287     * @param msg the message containing a password
     288     *
     289     * @throws IOException if an IO error occurs
     290     */
     291    protected void onLock(SshAgentLock msg) throws IOException {
     292        if (keystore.lock(msg.getPassword())) {
     293            sendAgentSuccess();
     294        } else {
     295            sendAgentFailure(SshAgentFailure.SSH_AGENT_ERROR_DENIED);
     296        }
     297    }
     298
     299    /**
     300     * Called by the remote side when the agent is to be unlocked
     301     *
     302     * @param msg the message containin the password
     303     *
     304     * @throws IOException if an IO error occurs
     305     */
     306    protected void onUnlock(SshAgentUnlock msg) throws IOException {
     307        if (keystore.unlock(msg.getPassword())) {
     308            sendAgentSuccess();
     309        } else {
     310            sendAgentFailure(SshAgentFailure.SSH_AGENT_ERROR_DENIED);
     311        }
     312    }
     313
     314    /**
     315     * Called when a ping message is received
     316     *
     317     * @param msg the ping message containing some padding
     318     *
     319     * @throws IOException if an IO error occurs
     320     */
     321    protected void onPing(SshAgentPing msg) throws IOException {
     322        sendAgentAlive(msg.getPadding());
     323    }
     324
     325    /**
     326     * Called when the remote side sends a random message
     327     *
     328     * @param msg the random message
     329     *
     330     * @throws IOException if an IO error occurs
     331     */
     332    protected void onRandom(SshAgentRandom msg) throws IOException {
     333        if (msg.getLength() > 0) {
     334            byte[] random = new byte[msg.getLength()];
     335            ConfigurationLoader.getRND().nextBytes(random);
     336            sendRandomData(random);
     337        } else {
     338            sendAgentFailure(SshAgentFailure.SSH_AGENT_ERROR_FAILURE);
     339        }
     340    }
     341
     342    /**
     343     * The connection thread
     344     */
     345    public void run() {
     346        try {
     347            log.info("Starting agent connection thread");
     348
     349            byte[] lendata = new byte[4];
     350            byte[] msgdata;
     351            int len;
     352            int read;
     353            boolean alive = true;
     354
     355            while (alive) {
     356                // Read the first 4 bytes to determine the length of the message
     357                len = 0;
     358
     359                while (len < lendata.length) {
     360                    try {
     361                        read = 0;
     362                        read = in.read(lendata, len, lendata.length - len);
     363
     364                        if (read >= 0) {
     365                            len += read;
     366                        } else {
     367                            alive = false;
     368
     369                            break;
     370                        }
     371                    } catch (InterruptedIOException ex) {
     372                        if (ex.bytesTransferred > 0) {
     373                            len += ex.bytesTransferred;
     374                        }
     375                    }
     376                }
     377
     378                if (alive) {
     379                    len = (int) ByteArrayReader.readInt(lendata, 0);
     380                    msgdata = new byte[len];
     381                    len = 0;
     382
     383                    while (len < msgdata.length) {
     384                        try {
     385                            len += in.read(msgdata, len, msgdata.length - len);
     386                        } catch (InterruptedIOException ex1) {
     387                            len += ex1.bytesTransferred;
     388                        }
     389                    }
     390
     391                    onMessageReceived(msgdata);
     392                }
     393            }
     394        } catch (IOException ex) {
     395            log.info("The agent connection terminated");
     396        } finally {
     397            try {
     398                socket.close();
     399            } catch (Exception ex) {
     400            }
     401        }
     402
     403        log.info("Exiting agent connection thread");
     404    }
     405
     406    /**
     407     * Process a message and route to the handler method
     408     *
     409     * @param msgdata the raw message received
     410     *
     411     * @throws IOException if an IO error occurs
     412     */
     413    protected void onMessageReceived(byte[] msgdata) throws IOException {
     414        switch ((int) (msgdata[0] & 0xFF)) {
     415        case SshAgentForwardingNotice.SSH_AGENT_FORWARDING_NOTICE: {
     416            log.info("Agent forwarding notice received");
     417
     418            SshAgentForwardingNotice msg = new SshAgentForwardingNotice();
     419            msg.fromByteArray(new ByteArrayReader(msgdata));
     420            onForwardingNotice(msg);
     421
     422            break;
     423        }
     424
     425        case SshAgentRequestVersion.SSH_AGENT_REQUEST_VERSION: {
     426            log.info("Agent version request received");
     427
     428            SshAgentRequestVersion msg = new SshAgentRequestVersion();
     429            msg.fromByteArray(new ByteArrayReader(msgdata));
     430            onRequestVersion(msg);
     431
     432            break;
     433        }
     434
     435        case SshAgentAddKey.SSH_AGENT_ADD_KEY: {
     436            log.info("Adding key to agent");
     437
     438            SshAgentAddKey msg = new SshAgentAddKey();
     439            msg.fromByteArray(new ByteArrayReader(msgdata));
     440            onAddKey(msg);
     441
     442            break;
     443        }
     444
     445        case SshAgentDeleteAllKeys.SSH_AGENT_DELETE_ALL_KEYS: {
     446            log.info("Deleting all keys from agent");
     447
     448            SshAgentDeleteAllKeys msg = new SshAgentDeleteAllKeys();
     449            msg.fromByteArray(new ByteArrayReader(msgdata));
     450            onDeleteAllKeys(msg);
     451
     452            break;
     453        }
     454
     455        case SshAgentListKeys.SSH_AGENT_LIST_KEYS: {
     456            log.info("Listing agent keys");
     457
     458            SshAgentListKeys msg = new SshAgentListKeys();
     459            msg.fromByteArray(new ByteArrayReader(msgdata));
     460            onListKeys(msg);
     461
     462            break;
     463        }
     464
     465        case SshAgentPrivateKeyOp.SSH_AGENT_PRIVATE_KEY_OP: {
     466            log.info("Performing agent private key operation");
     467
     468            SshAgentPrivateKeyOp msg = new SshAgentPrivateKeyOp();
     469            msg.fromByteArray(new ByteArrayReader(msgdata));
     470            onPrivateKeyOp(msg);
     471
     472            break;
     473        }
     474
     475        case SshAgentDeleteKey.SSH_AGENT_DELETE_KEY: {
     476            log.info("Deleting key from agent");
     477
     478            SshAgentDeleteKey msg = new SshAgentDeleteKey();
     479            msg.fromByteArray(new ByteArrayReader(msgdata));
     480            onDeleteKey(msg);
     481
     482            break;
     483        }
     484
     485        case SshAgentLock.SSH_AGENT_LOCK: {
     486            log.info("Locking agent");
     487
     488            SshAgentLock msg = new SshAgentLock();
     489            msg.fromByteArray(new ByteArrayReader(msgdata));
     490            onLock(msg);
     491
     492            break;
     493        }
     494
     495        case SshAgentUnlock.SSH_AGENT_UNLOCK: {
     496            log.info("Unlocking agent");
     497
     498            SshAgentUnlock msg = new SshAgentUnlock();
     499            msg.fromByteArray(new ByteArrayReader(msgdata));
     500            onUnlock(msg);
     501
     502            break;
     503        }
     504
     505        case SshAgentPing.SSH_AGENT_PING: {
     506            log.info("Ping Ping Ping Ping Ping");
     507
     508            SshAgentPing msg = new SshAgentPing();
     509            msg.fromByteArray(new ByteArrayReader(msgdata));
     510            onPing(msg);
     511
     512            break;
     513        }
     514
     515        case SshAgentRandom.SSH_AGENT_RANDOM: {
     516            log.info("Random message received");
     517
     518            SshAgentRandom msg = new SshAgentRandom();
     519            msg.fromByteArray(new ByteArrayReader(msgdata));
     520            onRandom(msg);
     521
     522            break;
     523        }
     524
     525        default:
     526            throw new IOException("Unrecognized message type " +
     527                String.valueOf(msgdata[0]) + " received");
     528        }
     529    }
     530}
  • source/com/sshtools/j2ssh/agent/SshAgentAlive.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32import com.sshtools.j2ssh.transport.InvalidMessageException;
     33
     34import java.io.IOException;
     35
     36
     37class SshAgentAlive extends SubsystemMessage {
     38    /**  */
     39    public static final int SSH_AGENT_ALIVE = 150;
     40    private byte[] padding;
     41
     42    /**
     43     * Creates a new SshAgentAlive object.
     44     */
     45    public SshAgentAlive() {
     46        super(SSH_AGENT_ALIVE);
     47    }
     48
     49    /**
     50     * Creates a new SshAgentAlive object.
     51     *
     52     * @param padding
     53     */
     54    public SshAgentAlive(byte[] padding) {
     55        super(SSH_AGENT_ALIVE);
     56        this.padding = padding;
     57    }
     58
     59    /**
     60     *
     61     *
     62     * @return
     63     */
     64    public byte[] getPadding() {
     65        return padding;
     66    }
     67
     68    /**
     69     *
     70     *
     71     * @return
     72     */
     73    public String getMessageName() {
     74        return "SSH_AGENT_ALIVE";
     75    }
     76
     77    /**
     78     *
     79     *
     80     * @param baw
     81     *
     82     * @throws java.io.IOException
     83     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     84     *         ME!
     85     * @throws InvalidMessageException
     86     */
     87    public void constructByteArray(ByteArrayWriter baw)
     88        throws java.io.IOException,
     89            com.sshtools.j2ssh.transport.InvalidMessageException {
     90        try {
     91            baw.write(padding);
     92        } catch (IOException ioe) {
     93            throw new InvalidMessageException(ioe.getMessage());
     94        }
     95    }
     96
     97    /**
     98     *
     99     *
     100     * @param bar
     101     *
     102     * @throws java.io.IOException
     103     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     104     *         ME!
     105     * @throws InvalidMessageException
     106     */
     107    public void constructMessage(ByteArrayReader bar)
     108        throws java.io.IOException,
     109            com.sshtools.j2ssh.transport.InvalidMessageException {
     110        try {
     111            padding = new byte[bar.available()];
     112            bar.read(padding);
     113        } catch (IOException ioe) {
     114            throw new InvalidMessageException(ioe.getMessage());
     115        }
     116    }
     117}
  • source/com/sshtools/j2ssh/agent/AgentAuthenticationClient.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.SshClient;
     30import com.sshtools.j2ssh.authentication.AuthenticationProtocolClient;
     31import com.sshtools.j2ssh.authentication.AuthenticationProtocolException;
     32import com.sshtools.j2ssh.authentication.AuthenticationProtocolState;
     33import com.sshtools.j2ssh.authentication.PublicKeyAuthenticationClient;
     34import com.sshtools.j2ssh.authentication.SshAuthenticationClient;
     35import com.sshtools.j2ssh.authentication.SshMsgUserAuthPKOK;
     36import com.sshtools.j2ssh.authentication.SshMsgUserAuthRequest;
     37import com.sshtools.j2ssh.authentication.TerminatedStateException;
     38import com.sshtools.j2ssh.io.ByteArrayWriter;
     39import com.sshtools.j2ssh.transport.SshMessage;
     40import com.sshtools.j2ssh.transport.publickey.SshPublicKey;
     41import org.apache.log4j.Logger;
     42
     43import java.awt.Component;
     44
     45import java.io.IOException;
     46
     47import java.util.Iterator;
     48import java.util.Map;
     49import java.util.Properties;
     50
     51
     52/**
     53 * <p>
     54 * Provides an application with an authentication mechanism that links to the
     55 * sshtools agent; the agent stores private keys and can hash and sign data
     56 * for the public key authentication request.
     57 * </p>
     58 *
     59 * @author Lee David Painter
     60 * @version $Revision: 1.19 $
     61 */
     62public class AgentAuthenticationClient extends SshAuthenticationClient {
     63    /**  */
     64        private static Logger log = Logger.getLogger(AgentAuthenticationClient.class);
     65    protected SshAgentClient agent;
     66
     67    /**
     68     * Creates a new AgentAuthenticationClient object.
     69     */
     70    public AgentAuthenticationClient() {
     71    }
     72
     73    /*public void setKey(SshPublicKey key) {
     74        this.key = key;
     75         }*/
     76    public void setAgent(SshAgentClient agent) {
     77        this.agent = agent;
     78    }
     79
     80    /**
     81     *
     82     */
     83    public void reset() {
     84        agent = null;
     85    }
     86
     87    /**
     88     *
     89     *
     90     * @return
     91     */
     92    public String getMethodName() {
     93        return "publickey";
     94    }
     95
     96    /**
     97     *
     98     *
     99     * @param authentication
     100     * @param username
     101     * @param serviceToStart
     102     * @param key
     103     *
     104     * @return
     105     *
     106     * @throws IOException
     107     */
     108    public boolean acceptsKey(AuthenticationProtocolClient authentication,
     109        String username, String serviceToStart, SshPublicKey key)
     110        throws IOException {
     111        authentication.registerMessage(SshMsgUserAuthPKOK.class,
     112            SshMsgUserAuthPKOK.SSH_MSG_USERAUTH_PK_OK);
     113        log.info(
     114            "Determining if server can accept public key for authentication");
     115
     116        ByteArrayWriter baw = new ByteArrayWriter();
     117
     118        // Now prepare and send the message
     119        baw.write(0);
     120        baw.writeString(key.getAlgorithmName());
     121        baw.writeBinaryString(key.getEncoded());
     122
     123        SshMessage msg = new SshMsgUserAuthRequest(username, serviceToStart,
     124                getMethodName(), baw.toByteArray());
     125        authentication.sendMessage(msg);
     126
     127        try {
     128            msg = authentication.readMessage(SshMsgUserAuthPKOK.SSH_MSG_USERAUTH_PK_OK);
     129
     130            if (msg instanceof SshMsgUserAuthPKOK) {
     131                return true;
     132            } else {
     133                throw new IOException(
     134                    "Unexpected message returned from readMessage");
     135            }
     136        } catch (TerminatedStateException ex) {
     137            return false;
     138        }
     139    }
     140
     141    /**
     142     *
     143     *
     144     * @param authentication
     145     * @param serviceToStart
     146     *
     147     * @throws IOException
     148     * @throws TerminatedStateException
     149     * @throws AuthenticationProtocolException
     150     */
     151    public void authenticate(AuthenticationProtocolClient authentication,
     152        String serviceToStart) throws IOException, TerminatedStateException {
     153        if ((getUsername() == null) || (agent == null)) {
     154            throw new AuthenticationProtocolException(
     155                "You must supply a username and agent");
     156        }
     157
     158        // Iterate the agents keys, find an acceptable key and authenticate
     159        Map keys = agent.listKeys();
     160        Iterator it = keys.entrySet().iterator();
     161        boolean acceptable = false;
     162        SshPublicKey key = null;
     163        String description;
     164        Map.Entry entry;
     165
     166        while (it.hasNext() && !acceptable) {
     167            entry = (Map.Entry) it.next();
     168            key = (SshPublicKey) entry.getKey();
     169            description = (String) entry.getValue();
     170            acceptable = acceptsKey(authentication, getUsername(),
     171                    serviceToStart, key);
     172            log.info("Agent authentication with key " + key.getFingerprint() +
     173                " [" + description + "] is " +
     174                (acceptable ? " acceptable" : " not acceptable"));
     175
     176            if (acceptable) {
     177                ByteArrayWriter baw = new ByteArrayWriter();
     178                log.info("Generating data to sign");
     179                log.info("Preparing public key authentication request");
     180
     181                // Now prepare and send the message
     182                baw.write(1);
     183                baw.writeString(key.getAlgorithmName());
     184                baw.writeBinaryString(key.getEncoded());
     185
     186                // Create the signature data
     187                ByteArrayWriter data = new ByteArrayWriter();
     188                data.writeBinaryString(authentication.getSessionIdentifier());
     189                data.write(SshMsgUserAuthRequest.SSH_MSG_USERAUTH_REQUEST);
     190                data.writeString(getUsername());
     191                data.writeString(serviceToStart);
     192                data.writeString(getMethodName());
     193                data.write(1);
     194                data.writeString(key.getAlgorithmName());
     195                data.writeBinaryString(key.getEncoded());
     196
     197                // Generate the signature
     198                baw.writeBinaryString(agent.hashAndSign(key, data.toByteArray()));
     199
     200                SshMsgUserAuthRequest msg = new SshMsgUserAuthRequest(getUsername(),
     201                        serviceToStart, getMethodName(), baw.toByteArray());
     202                authentication.sendMessage(msg);
     203
     204                try {
     205                    authentication.readAuthenticationState();
     206                } catch (TerminatedStateException ex) {
     207                    if (ex.getState() == AuthenticationProtocolState.COMPLETE) {
     208                        throw ex;
     209                    }
     210                }
     211            }
     212        }
     213
     214        throw new TerminatedStateException(AuthenticationProtocolState.FAILED);
     215    }
     216
     217    /**
     218     *
     219     *
     220     * @param parent
     221     *
     222     * @return
     223     */
     224    public boolean showAuthenticationDialog(Component parent) {
     225        return false;
     226    }
     227
     228    /**
     229     *
     230     *
     231     * @return
     232     */
     233    public Properties getPersistableProperties() {
     234        Properties properties = new Properties();
     235
     236        return properties;
     237    }
     238
     239    /**
     240     *
     241     *
     242     * @param properties
     243     */
     244    public void setPersistableProperties(Properties properties) {
     245    }
     246
     247    /**
     248     *
     249     *
     250     * @return
     251     */
     252    public boolean canAuthenticate() {
     253        return ((agent != null) && (getUsername() != null));
     254    }
     255
     256    /**
     257     *
     258     *
     259     * @param ssh
     260     *
     261     * @return
     262     */
     263    public boolean hasAcceptableKey(SshClient ssh) {
     264        try {
     265            Map keys = agent.listKeys();
     266            SshPublicKey key;
     267
     268            for (Iterator x = keys.keySet().iterator(); x.hasNext();) {
     269                key = (SshPublicKey) x.next();
     270
     271                if (ssh.acceptsKey(getUsername(), key)) {
     272                    return true;
     273                }
     274            }
     275        } catch (IOException ex) {
     276        }
     277
     278        return false;
     279    }
     280}
  • source/com/sshtools/j2ssh/agent/SshAgentAddKey.java

     
     1/*
     2 *  SSHTools - Java SSH2 API
     3 *
     4 *  Copyright (C) 2002-2003 Lee David Painter and Contributors.
     5 *
     6 *  Contributions made by:
     7 *
     8 *  Brett Smith
     9 *  Richard Pernavas
     10 *  Erwin Bolwidt
     11 *
     12 *  This program is free software; you can redistribute it and/or
     13 *  modify it under the terms of the GNU Library General Public License
     14 *  as published by the Free Software Foundation; either version 2 of
     15 *  the License, or (at your option) any later version.
     16 *
     17 *  You may also distribute it and/or modify it under the terms of the
     18 *  Apache style J2SSH Software License. A copy of which should have
     19 *  been provided with the distribution.
     20 *
     21 *  This program is distributed in the hope that it will be useful,
     22 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     23 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     24 *  License document supplied with your distribution for more details.
     25 *
     26 */
     27package com.sshtools.j2ssh.agent;
     28
     29import com.sshtools.j2ssh.io.ByteArrayReader;
     30import com.sshtools.j2ssh.io.ByteArrayWriter;
     31import com.sshtools.j2ssh.subsystem.SubsystemMessage;
     32import com.sshtools.j2ssh.transport.InvalidMessageException;
     33import com.sshtools.j2ssh.transport.publickey.SshKeyPairFactory;
     34import com.sshtools.j2ssh.transport.publickey.SshPrivateKey;
     35import com.sshtools.j2ssh.transport.publickey.SshPublicKey;
     36
     37import java.io.IOException;
     38
     39
     40class SshAgentAddKey extends SubsystemMessage {
     41    /**  */
     42    public static final int SSH_AGENT_ADD_KEY = 202;
     43    SshPrivateKey prvkey;
     44    SshPublicKey pubkey;
     45    String description;
     46    KeyConstraints constraints;
     47
     48    /**
     49     * Creates a new SshAgentAddKey object.
     50     */
     51    public SshAgentAddKey() {
     52        super(SSH_AGENT_ADD_KEY);
     53    }
     54
     55    /**
     56     * Creates a new SshAgentAddKey object.
     57     *
     58     * @param prvkey
     59     * @param pubkey
     60     * @param description
     61     * @param constraints
     62     */
     63    public SshAgentAddKey(SshPrivateKey prvkey, SshPublicKey pubkey,
     64        String description, KeyConstraints constraints) {
     65        super(SSH_AGENT_ADD_KEY);
     66        this.prvkey = prvkey;
     67        this.pubkey = pubkey;
     68        this.description = description;
     69        this.constraints = constraints;
     70    }
     71
     72    /**
     73     *
     74     *
     75     * @return
     76     */
     77    public SshPrivateKey getPrivateKey() {
     78        return prvkey;
     79    }
     80
     81    /**
     82     *
     83     *
     84     * @return
     85     */
     86    public SshPublicKey getPublicKey() {
     87        return pubkey;
     88    }
     89
     90    /**
     91     *
     92     *
     93     * @return
     94     */
     95    public String getDescription() {
     96        return description;
     97    }
     98
     99    /**
     100     *
     101     *
     102     * @return
     103     */
     104    public KeyConstraints getKeyConstraints() {
     105        return constraints;
     106    }
     107
     108    /**
     109     *
     110     *
     111     * @return
     112     */
     113    public String getMessageName() {
     114        return "SSH_AGENT_ADD_KEY";
     115    }
     116
     117    /**
     118     *
     119     *
     120     * @param baw
     121     *
     122     * @throws java.io.IOException
     123     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     124     *         ME!
     125     * @throws InvalidMessageException
     126     */
     127    public void constructByteArray(ByteArrayWriter baw)
     128        throws java.io.IOException,
     129            com.sshtools.j2ssh.transport.InvalidMessageException {
     130        try {
     131            baw.writeBinaryString(prvkey.getEncoded());
     132            baw.writeBinaryString(pubkey.getEncoded());
     133            baw.writeString(description);
     134            baw.write(constraints.toByteArray());
     135        } catch (IOException ex) {
     136            throw new InvalidMessageException(ex.getMessage());
     137        }
     138    }
     139
     140    /**
     141     *
     142     *
     143     * @param bar
     144     *
     145     * @throws java.io.IOException
     146     * @throws com.sshtools.j2ssh.transport.InvalidMessageException DOCUMENT
     147     *         ME!
     148     * @throws InvalidMessageException
     149     */
     150    public void constructMessage(ByteArrayReader bar)
     151        throws java.io.IOException,
     152            com.sshtools.j2ssh.transport.InvalidMessageException {
     153        try {
     154            prvkey = SshKeyPairFactory.decodePrivateKey(bar.readBinaryString());
     155            pubkey = SshKeyPairFactory.decodePublicKey(bar.readBinaryString());
     156            description = bar.readString();
     157            constraints = new KeyConstraints(bar);
     158        } catch (IOException ex) {
     159            throw new InvalidMessageException(ex.getMessage());
     160        }
     161    }
     162}
  • source/com/sshtools/j2ssh/subsystem/SubsystemMessage.java

     
    7676         * @throws InvalidMessageException
    7777         */
    7878        public void fromByteArray(byte[] data, String encoding) throws InvalidMessageException {
     79                fromByteArray(new ByteArrayReader(data, encoding));
     80        }
     81       
     82        /**
     83         * @param data
     84         * @throws InvalidMessageException
     85         */
     86        public void fromByteArray(ByteArrayReader bar) throws InvalidMessageException {
    7987                try {
    80                         ByteArrayReader bar = new ByteArrayReader(data, encoding);
    8188                        if(bar.available() > 0) {
    8289                                type = bar.read();
    8390                                constructMessage(bar);
     
    9097                        throw new InvalidMessageException("The message data cannot be read!");
    9198                }
    9299        }
     100               
    93101
    94102        /**
    95103         * @return
  • Cyberduck.xcodeproj/project.pbxproj

     
    196196                47FD45730801ED1D00716715 /* ftp.tiff in Resources */ = {isa = PBXBuildFile; fileRef = 47FD456F0801ED1C00716715 /* ftp.tiff */; };
    197197                47FD45740801ED1D00716715 /* general.tiff in Resources */ = {isa = PBXBuildFile; fileRef = 47FD45700801ED1C00716715 /* general.tiff */; };
    198198                47FF630407F34E6100C0BDB9 /* gear.tiff in Resources */ = {isa = PBXBuildFile; fileRef = 47FF630307F34E6100C0BDB9 /* gear.tiff */; };
     199                5618FAE90AC851EC00CC9A3F /* UnixDomainSocket.c in Sources */ = {isa = PBXBuildFile; fileRef = 5618FAE40AC8518900CC9A3F /* UnixDomainSocket.c */; };
     200                5618FAED0AC8521200CC9A3F /* JavaVM.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4725BE0A05D2E27000C7CCBD /* JavaVM.framework */; };
    199201/* End PBXBuildFile section */
    200202
    201203/* Begin PBXContainerItemProxy section */
     
    262264                        remoteGlobalIDString = 471D2C0B05A2505500675163;
    263265                        remoteInfo = app;
    264266                };
     267                5618FBC00AC854BD00CC9A3F /* PBXContainerItemProxy */ = {
     268                        isa = PBXContainerItemProxy;
     269                        containerPortal = 29B97313FDCFA39411CA2CEA /* Project object */;
     270                        proxyType = 1;
     271                        remoteGlobalIDString = 5618FAC90AC850F600CC9A3F /* libUnixDomainSocket */;
     272                        remoteInfo = libUnixDomainSocket;
     273                };
    265274/* End PBXContainerItemProxy section */
    266275
    267276/* Begin PBXCopyFilesBuildPhase section */
     
    14491458                47FD456F0801ED1C00716715 /* ftp.tiff */ = {isa = PBXFileReference; lastKnownFileType = image.tiff; path = ftp.tiff; sourceTree = "<group>"; };
    14501459                47FD45700801ED1C00716715 /* general.tiff */ = {isa = PBXFileReference; lastKnownFileType = image.tiff; path = general.tiff; sourceTree = "<group>"; };
    14511460                47FF630307F34E6100C0BDB9 /* gear.tiff */ = {isa = PBXFileReference; lastKnownFileType = image.tiff; path = gear.tiff; sourceTree = "<group>"; };
     1461                5618F9B00AC812D500CC9A3F /* AgentAuthenticationClient.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = AgentAuthenticationClient.java; sourceTree = "<group>"; };
     1462                5618F9B10AC812D500CC9A3F /* AgentNotAvailableException.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = AgentNotAvailableException.java; sourceTree = "<group>"; };
     1463                5618F9B20AC812D500CC9A3F /* AgentSocketChannel.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = AgentSocketChannel.java; sourceTree = "<group>"; };
     1464                5618F9B30AC812D500CC9A3F /* ForwardingNotice.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = ForwardingNotice.java; sourceTree = "<group>"; };
     1465                5618F9B40AC812D500CC9A3F /* KeyConstraints.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = KeyConstraints.java; sourceTree = "<group>"; };
     1466                5618F9B50AC812D500CC9A3F /* KeyStore.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = KeyStore.java; sourceTree = "<group>"; };
     1467                5618F9B60AC812D500CC9A3F /* KeyStoreListener.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = KeyStoreListener.java; sourceTree = "<group>"; };
     1468                5618F9B70AC812D500CC9A3F /* KeyTimeoutException.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = KeyTimeoutException.java; sourceTree = "<group>"; };
     1469                5618F9B80AC812D500CC9A3F /* SshAgentAddKey.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentAddKey.java; sourceTree = "<group>"; };
     1470                5618F9B90AC812D500CC9A3F /* SshAgentAlive.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentAlive.java; sourceTree = "<group>"; };
     1471                5618F9BA0AC812D500CC9A3F /* SshAgentClient.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentClient.java; sourceTree = "<group>"; };
     1472                5618F9BB0AC812D500CC9A3F /* SshAgentConnection.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentConnection.java; sourceTree = "<group>"; };
     1473                5618F9BC0AC812D500CC9A3F /* SshAgentDeleteAllKeys.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentDeleteAllKeys.java; sourceTree = "<group>"; };
     1474                5618F9BD0AC812D500CC9A3F /* SshAgentDeleteKey.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentDeleteKey.java; sourceTree = "<group>"; };
     1475                5618F9BE0AC812D500CC9A3F /* SshAgentFailure.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentFailure.java; sourceTree = "<group>"; };
     1476                5618F9BF0AC812D500CC9A3F /* SshAgentForwardingListener.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentForwardingListener.java; sourceTree = "<group>"; };
     1477                5618F9C00AC812D500CC9A3F /* SshAgentForwardingNotice.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentForwardingNotice.java; sourceTree = "<group>"; };
     1478                5618F9C10AC812D500CC9A3F /* SshAgentKeyList.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentKeyList.java; sourceTree = "<group>"; };
     1479                5618F9C20AC812D500CC9A3F /* SshAgentListKeys.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentListKeys.java; sourceTree = "<group>"; };
     1480                5618F9C30AC812D500CC9A3F /* SshAgentLock.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentLock.java; sourceTree = "<group>"; };
     1481                5618F9C40AC812D500CC9A3F /* SshAgentOperationComplete.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentOperationComplete.java; sourceTree = "<group>"; };
     1482                5618F9C50AC812D500CC9A3F /* SshAgentPing.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentPing.java; sourceTree = "<group>"; };
     1483                5618F9C60AC812D500CC9A3F /* SshAgentPrivateKeyOp.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentPrivateKeyOp.java; sourceTree = "<group>"; };
     1484                5618F9C70AC812D500CC9A3F /* SshAgentRandom.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentRandom.java; sourceTree = "<group>"; };
     1485                5618F9C80AC812D500CC9A3F /* SshAgentRandomData.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentRandomData.java; sourceTree = "<group>"; };
     1486                5618F9C90AC812D500CC9A3F /* SshAgentRequestVersion.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentRequestVersion.java; sourceTree = "<group>"; };
     1487                5618F9CA0AC812D500CC9A3F /* SshAgentSocketListener.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentSocketListener.java; sourceTree = "<group>"; };
     1488                5618F9CB0AC812D500CC9A3F /* SshAgentSuccess.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentSuccess.java; sourceTree = "<group>"; };
     1489                5618F9CC0AC812D500CC9A3F /* SshAgentUnlock.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentUnlock.java; sourceTree = "<group>"; };
     1490                5618F9CD0AC812D500CC9A3F /* SshAgentVersionResponse.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = SshAgentVersionResponse.java; sourceTree = "<group>"; };
     1491                5618FACA0AC850F600CC9A3F /* libUnixDomainSockets.dylib */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.dylib"; includeInIndex = 0; path = libUnixDomainSockets.dylib; sourceTree = BUILT_PRODUCTS_DIR; };
     1492                5618FAE40AC8518900CC9A3F /* UnixDomainSocket.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = UnixDomainSocket.c; sourceTree = "<group>"; };
     1493                5618FAE50AC8518900CC9A3F /* UnixDomainSocket.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; path = UnixDomainSocket.java; sourceTree = "<group>"; };
    14521494/* End PBXFileReference section */
    14531495
    14541496/* Begin PBXFrameworksBuildPhase section */
     
    15371579                        );
    15381580                        runOnlyForDeploymentPostprocessing = 0;
    15391581                };
     1582                5618FAC80AC850F600CC9A3F /* Frameworks */ = {
     1583                        isa = PBXFrameworksBuildPhase;
     1584                        buildActionMask = 2147483647;
     1585                        files = (
     1586                                5618FAED0AC8521200CC9A3F /* JavaVM.framework in Frameworks */,
     1587                        );
     1588                        runOnlyForDeploymentPostprocessing = 0;
     1589                };
    15401590/* End PBXFrameworksBuildPhase section */
    15411591
    15421592/* Begin PBXGroup section */
     
    15511601                                4739EFC10856991300405FD3 /* libLocal.dylib */,
    15521602                                4716D8B80877533B00938886 /* libDotMac.dylib */,
    15531603                                4762DAC509FC42EC0034C662 /* libDiagnostics.dylib */,
     1604                                5618FACA0AC850F600CC9A3F /* libUnixDomainSockets.dylib */,
    15541605                        );
    15551606                        name = Products;
    15561607                        sourceTree = "<group>";
     
    19141965                4741532B06C4F08A00AC0BD2 /* com */ = {
    19151966                        isa = PBXGroup;
    19161967                        children = (
     1968                                5618FAE20AC8518800CC9A3F /* echogent */,
    19171969                                478B362F0A07C395000F11F2 /* macfoh */,
    19181970                                4727224509F51F2600136347 /* adiumx */,
    19191971                                4741532C06C4F08A00AC0BD2 /* enterprisedt */,
     
    19672019                4741533906C4F08A00AC0BD2 /* j2ssh */ = {
    19682020                        isa = PBXGroup;
    19692021                        children = (
     2022                                5618F9AF0AC812D400CC9A3F /* agent */,
    19702023                                4741535906C4F08A00AC0BD2 /* authentication */,
    19712024                                4741537106C4F08A00AC0BD2 /* configuration */,
    19722025                                4741537806C4F08A00AC0BD2 /* connection */,
     
    27712824                        path = core;
    27722825                        sourceTree = "<group>";
    27732826                };
     2827                5618F9AF0AC812D400CC9A3F /* agent */ = {
     2828                        isa = PBXGroup;
     2829                        children = (
     2830                                5618F9B00AC812D500CC9A3F /* AgentAuthenticationClient.java */,
     2831                                5618F9B10AC812D500CC9A3F /* AgentNotAvailableException.java */,
     2832                                5618F9B20AC812D500CC9A3F /* AgentSocketChannel.java */,
     2833                                5618F9B30AC812D500CC9A3F /* ForwardingNotice.java */,
     2834                                5618F9B40AC812D500CC9A3F /* KeyConstraints.java */,
     2835                                5618F9B50AC812D500CC9A3F /* KeyStore.java */,
     2836                                5618F9B60AC812D500CC9A3F /* KeyStoreListener.java */,
     2837                                5618F9B70AC812D500CC9A3F /* KeyTimeoutException.java */,
     2838                                5618F9B80AC812D500CC9A3F /* SshAgentAddKey.java */,
     2839                                5618F9B90AC812D500CC9A3F /* SshAgentAlive.java */,
     2840                                5618F9BA0AC812D500CC9A3F /* SshAgentClient.java */,
     2841                                5618F9BB0AC812D500CC9A3F /* SshAgentConnection.java */,
     2842                                5618F9BC0AC812D500CC9A3F /* SshAgentDeleteAllKeys.java */,
     2843                                5618F9BD0AC812D500CC9A3F /* SshAgentDeleteKey.java */,
     2844                                5618F9BE0AC812D500CC9A3F /* SshAgentFailure.java */,
     2845                                5618F9BF0AC812D500CC9A3F /* SshAgentForwardingListener.java */,
     2846                                5618F9C00AC812D500CC9A3F /* SshAgentForwardingNotice.java */,
     2847                                5618F9C10AC812D500CC9A3F /* SshAgentKeyList.java */,
     2848                                5618F9C20AC812D500CC9A3F /* SshAgentListKeys.java */,
     2849                                5618F9C30AC812D500CC9A3F /* SshAgentLock.java */,
     2850                                5618F9C40AC812D500CC9A3F /* SshAgentOperationComplete.java */,
     2851                                5618F9C50AC812D500CC9A3F /* SshAgentPing.java */,
     2852                                5618F9C60AC812D500CC9A3F /* SshAgentPrivateKeyOp.java */,
     2853                                5618F9C70AC812D500CC9A3F /* SshAgentRandom.java */,
     2854                                5618F9C80AC812D500CC9A3F /* SshAgentRandomData.java */,
     2855                                5618F9C90AC812D500CC9A3F /* SshAgentRequestVersion.java */,
     2856                                5618F9CA0AC812D500CC9A3F /* SshAgentSocketListener.java */,
     2857                                5618F9CB0AC812D500CC9A3F /* SshAgentSuccess.java */,
     2858                                5618F9CC0AC812D500CC9A3F /* SshAgentUnlock.java */,
     2859                                5618F9CD0AC812D500CC9A3F /* SshAgentVersionResponse.java */,
     2860                        );
     2861                        path = agent;
     2862                        sourceTree = "<group>";
     2863                };
     2864                5618FAE20AC8518800CC9A3F /* echogent */ = {
     2865                        isa = PBXGroup;
     2866                        children = (
     2867                                5618FAE30AC8518800CC9A3F /* jbuds */,
     2868                        );
     2869                        path = echogent;
     2870                        sourceTree = "<group>";
     2871                };
     2872                5618FAE30AC8518800CC9A3F /* jbuds */ = {
     2873                        isa = PBXGroup;
     2874                        children = (
     2875                                5618FAE40AC8518900CC9A3F /* UnixDomainSocket.c */,
     2876                                5618FAE50AC8518900CC9A3F /* UnixDomainSocket.java */,
     2877                        );
     2878                        path = jbuds;
     2879                        sourceTree = "<group>";
     2880                };
    27742881/* End PBXGroup section */
    27752882
    27762883/* Begin PBXHeadersBuildPhase section */
     
    28552962                        );
    28562963                        runOnlyForDeploymentPostprocessing = 0;
    28572964                };
     2965                5618FAC60AC850F600CC9A3F /* Headers */ = {
     2966                        isa = PBXHeadersBuildPhase;
     2967                        buildActionMask = 2147483647;
     2968                        files = (
     2969                        );
     2970                        runOnlyForDeploymentPostprocessing = 0;
     2971                };
    28582972/* End PBXHeadersBuildPhase section */
    28592973
    28602974/* Begin PBXLegacyTarget section */
     
    29283042                                471E21540A1734D7009E164E /* PBXTargetDependency */,
    29293043                                471E21560A1734D7009E164E /* PBXTargetDependency */,
    29303044                                471E21580A1734D7009E164E /* PBXTargetDependency */,
     3045                                5618FBC10AC854BD00CC9A3F /* PBXTargetDependency */,
    29313046                        );
    29323047                        name = "app (International)";
    29333048                        productInstallPath = "$(USER_APPS_DIR)";
     
    30493164                        productReference = 4762DAC509FC42EC0034C662 /* libDiagnostics.dylib */;
    30503165                        productType = "com.apple.product-type.library.dynamic";
    30513166                };
     3167                5618FAC90AC850F600CC9A3F /* libUnixDomainSocket */ = {
     3168                        isa = PBXNativeTarget;
     3169                        buildConfigurationList = 5618FADE0AC8510300CC9A3F /* Build configuration list for PBXNativeTarget "libUnixDomainSocket" */;
     3170                        buildPhases = (
     3171                                5618FAC60AC850F600CC9A3F /* Headers */,
     3172                                5618FAC70AC850F600CC9A3F /* Sources */,
     3173                                5618FAC80AC850F600CC9A3F /* Frameworks */,
     3174                        );
     3175                        buildRules = (
     3176                        );
     3177                        dependencies = (
     3178                        );
     3179                        name = libUnixDomainSocket;
     3180                        productName = libUnixDomainSockets;
     3181                        productReference = 5618FACA0AC850F600CC9A3F /* libUnixDomainSockets.dylib */;
     3182                        productType = "com.apple.product-type.library.dynamic";
     3183                };
    30523184/* End PBXNativeTarget section */
    30533185
    30543186/* Begin PBXProject section */
     
    31053237                                4739EFB10856991200405FD3 /* libLocal */,
    31063238                                4716D8AC0877533B00938886 /* libDotMac */,
    31073239                                4762DAB809FC42EC0034C662 /* libDiagnostics */,
     3240                                5618FAC90AC850F600CC9A3F /* libUnixDomainSocket */,
    31083241                        );
    31093242                };
    31103243/* End PBXProject section */
     
    33593492                        );
    33603493                        runOnlyForDeploymentPostprocessing = 0;
    33613494                };
     3495                5618FAC70AC850F600CC9A3F /* Sources */ = {
     3496                        isa = PBXSourcesBuildPhase;
     3497                        buildActionMask = 2147483647;
     3498                        files = (
     3499                                5618FAE90AC851EC00CC9A3F /* UnixDomainSocket.c in Sources */,
     3500                        );
     3501                        runOnlyForDeploymentPostprocessing = 0;
     3502                };
    33623503/* End PBXSourcesBuildPhase section */
    33633504
    33643505/* Begin PBXTargetDependency section */
     
    34073548                        target = 471D2C0B05A2505500675163 /* app (International) */;
    34083549                        targetProxy = 47CD9C4F0739339B00E9379E /* PBXContainerItemProxy */;
    34093550                };
     3551                5618FBC10AC854BD00CC9A3F /* PBXTargetDependency */ = {
     3552                        isa = PBXTargetDependency;
     3553                        target = 5618FAC90AC850F600CC9A3F /* libUnixDomainSocket */;
     3554                        targetProxy = 5618FBC00AC854BD00CC9A3F /* PBXContainerItemProxy */;
     3555                };
    34103556/* End PBXTargetDependency section */
    34113557
    34123558/* Begin PBXVariantGroup section */
     
    45254671                        };
    45264672                        name = Deployment;
    45274673                };
     4674                5618FADF0AC8510300CC9A3F /* Deployment */ = {
     4675                        isa = XCBuildConfiguration;
     4676                        buildSettings = {
     4677                                COPY_PHASE_STRIP = YES;
     4678                                EXECUTABLE_PREFIX = "";
     4679                                FRAMEWORK_SEARCH_PATHS = "\"$(SRCROOT)/build\"";
     4680                                GCC_ENABLE_FIX_AND_CONTINUE = NO;
     4681                                GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
     4682                                GCC_MODEL_TUNING = G4;
     4683                                HEADER_SEARCH_PATHS = (
     4684                                        source/ch/cyberduck/core,
     4685                                        "$(SYSTEM_LIBRARY_DIR)/Frameworks/JavaVM.framework/Headers",
     4686                                );
     4687                                INSTALL_PATH = /usr/local/lib;
     4688                                PREBINDING = NO;
     4689                                PRODUCT_NAME = libUnixDomainSockets;
     4690                                ZERO_LINK = NO;
     4691                        };
     4692                        name = Deployment;
     4693                };
    45284694/* End XCBuildConfiguration section */
    45294695
    45304696/* Begin XCConfigurationList section */
     
    46164782                        defaultConfigurationIsVisible = 0;
    46174783                        defaultConfigurationName = Deployment;
    46184784                };
     4785                5618FADE0AC8510300CC9A3F /* Build configuration list for PBXNativeTarget "libUnixDomainSocket" */ = {
     4786                        isa = XCConfigurationList;
     4787                        buildConfigurations = (
     4788                                5618FADF0AC8510300CC9A3F /* Deployment */,
     4789                        );
     4790                        defaultConfigurationIsVisible = 0;
     4791                        defaultConfigurationName = Deployment;
     4792                };
    46194793/* End XCConfigurationList section */
    46204794        };
    46214795        rootObject = 29B97313FDCFA39411CA2CEA /* Project object */;
swiss made software