@Override
public Boolean doAuth(Buffer buffer, boolean init) throws Exception {
ValidateUtils.checkTrue(init, "Instance not initialized");
boolean hasSig = buffer.getBoolean();
String alg = buffer.getString();
int oldLim = buffer.wpos();
int oldPos = buffer.rpos();
int len = buffer.getInt();
buffer.wpos(buffer.rpos() + len);
PublicKey key = buffer.getRawPublicKey();
ServerFactoryManager manager = session.getFactoryManager();
Signature verif =
ValidateUtils.checkNotNull(
NamedFactory.Utils.create(manager.getSignatureFactories(), alg),
"No verifier located for algorithm=%s",
alg);
verif.initVerifier(key);
buffer.wpos(oldLim);
byte[] sig = hasSig ? buffer.getBytes() : null;
PublickeyAuthenticator authenticator =
ValidateUtils.checkNotNull(
manager.getPublickeyAuthenticator(), "No PublickeyAuthenticator configured");
if (!authenticator.authenticate(username, key, session)) {
return Boolean.FALSE;
}
if (!hasSig) {
Buffer buf = session.createBuffer(SshConstants.SSH_MSG_USERAUTH_PK_OK);
buf.putString(alg);
buf.putRawBytes(buffer.array(), oldPos, 4 + len);
session.writePacket(buf);
return null;
} else {
Buffer buf = new ByteArrayBuffer();
buf.putBytes(session.getKex().getH());
buf.putByte(SshConstants.SSH_MSG_USERAUTH_REQUEST);
buf.putString(username);
buf.putString(service);
buf.putString(UserAuthPublicKeyFactory.NAME);
buf.putBoolean(true);
buf.putString(alg);
buffer.rpos(oldPos);
buffer.wpos(oldPos + 4 + len);
buf.putBuffer(buffer);
verif.update(buf.array(), buf.rpos(), buf.available());
if (!verif.verify(sig)) {
throw new Exception("Key verification failed");
}
return Boolean.TRUE;
}
}
/**
* @param extraSize Extra size - besides the extension name
* @return A {@link Buffer} with the extension name set
*/
protected Buffer getCommandBuffer(int extraSize) {
String opcode = getName();
Buffer buffer =
new ByteArrayBuffer(
(Integer.SIZE / Byte.SIZE) + GenericUtils.length(opcode) + extraSize + Byte.SIZE);
buffer.putString(opcode);
return buffer;
}
/**
* @param buffer The {@link Buffer}
* @param target A target path {@link String} or {@link Handle} or {@code byte[]} to be encoded in
* the buffer
* @return The updated buffer
* @throws UnsupportedOperationException If target is not one of the above supported types
*/
public Buffer putTarget(Buffer buffer, Object target) {
if (target instanceof CharSequence) {
buffer.putString(target.toString());
} else if (target instanceof byte[]) {
buffer.putBytes((byte[]) target);
} else if (target instanceof Handle) {
buffer.putBytes(((Handle) target).getIdentifier());
} else {
throw new UnsupportedOperationException("Unknown target type: " + target);
}
return buffer;
}
@Override
public synchronized SshdSocketAddress startRemotePortForwarding(
SshdSocketAddress remote, SshdSocketAddress local) throws IOException {
ValidateUtils.checkNotNull(local, "Local address is null");
ValidateUtils.checkNotNull(remote, "Remote address is null");
Buffer buffer = session.createBuffer(SshConstants.SSH_MSG_GLOBAL_REQUEST);
buffer.putString("tcpip-forward");
buffer.putBoolean(true);
buffer.putString(remote.getHostName());
buffer.putInt(remote.getPort());
Buffer result = session.request(buffer);
if (result == null) {
throw new SshException("Tcpip forwarding request denied by server");
}
int port = (remote.getPort() == 0) ? result.getInt() : remote.getPort();
// TODO: Is it really safe to only store the local address after the request ?
SshdSocketAddress prev;
synchronized (remoteToLocal) {
prev = remoteToLocal.put(port, local);
}
if (prev != null) {
throw new IOException(
"Multiple remote port forwarding bindings on port="
+ port
+ ": current="
+ remote
+ ", previous="
+ prev);
}
SshdSocketAddress bound = new SshdSocketAddress(remote.getHostName(), port);
if (log.isDebugEnabled()) {
log.debug("startRemotePortForwarding(" + remote + " -> " + local + "): " + bound);
}
return bound;
}
protected void sendHeartBeat() {
String request =
FactoryManagerUtils.getStringProperty(
session,
ClientFactoryManager.HEARTBEAT_REQUEST,
ClientFactoryManager.DEFAULT_KEEP_ALIVE_HEARTBEAT_STRING);
try {
Buffer buf = session.createBuffer(SshConstants.SSH_MSG_GLOBAL_REQUEST);
buf.putString(request);
buf.putBoolean(false);
session.writePacket(buf);
} catch (IOException e) {
log.info("Error sending keepalive message=" + request, e);
}
}
@Override
public synchronized void stopRemotePortForwarding(SshdSocketAddress remote) throws IOException {
SshdSocketAddress bound;
synchronized (remoteToLocal) {
bound = remoteToLocal.remove(remote.getPort());
}
if (bound != null) {
if (log.isDebugEnabled()) {
log.debug("stopRemotePortForwarding(" + remote + ") cancel forwarding to " + bound);
}
Buffer buffer = session.createBuffer(SshConstants.SSH_MSG_GLOBAL_REQUEST);
buffer.putString("cancel-tcpip-forward");
buffer.putBoolean(false);
buffer.putString(remote.getHostName());
buffer.putInt(remote.getPort());
session.writePacket(buffer);
} else {
if (log.isDebugEnabled()) {
log.debug("stopRemotePortForwarding(" + remote + ") no binding found");
}
}
}
protected Pair<String, Collection<byte[]>> doGetHash(
Object target, Collection<String> algorithms, long offset, long length, int blockSize)
throws IOException {
Buffer buffer = getCommandBuffer(target, Byte.MAX_VALUE);
putTarget(buffer, target);
buffer.putString(GenericUtils.join(algorithms, ','));
buffer.putLong(offset);
buffer.putLong(length);
buffer.putInt(blockSize);
if (log.isDebugEnabled()) {
log.debug(
"doGetHash({})[{}] - offset={}, length={}, block-size={}",
getName(),
(target instanceof CharSequence)
? target
: BufferUtils.toHex(BufferUtils.EMPTY_HEX_SEPARATOR, (byte[]) target),
offset,
length,
blockSize);
}
buffer = checkExtendedReplyBuffer(receive(sendExtendedCommand(buffer)));
if (buffer == null) {
throw new StreamCorruptedException("Missing extended reply data");
}
String targetType = buffer.getString();
if (String.CASE_INSENSITIVE_ORDER.compare(targetType, SftpConstants.EXT_CHECK_FILE) != 0) {
throw new StreamCorruptedException(
"Mismatched reply type: expected="
+ SftpConstants.EXT_CHECK_FILE
+ ", actual="
+ targetType);
}
String algo = buffer.getString();
Collection<byte[]> hashes = new LinkedList<>();
while (buffer.available() > 0) {
byte[] hashValue = buffer.getBytes();
hashes.add(hashValue);
}
return new Pair<String, Collection<byte[]>>(algo, hashes);
}
@Override
public synchronized OpenFuture open() throws IOException {
if (isClosing()) {
throw new SshException("Session has been closed");
}
openFuture = new DefaultOpenFuture(lock);
if (log.isDebugEnabled()) {
log.debug("open({}) Send SSH_MSG_CHANNEL_OPEN - type={}", this, type);
}
Session session = getSession();
Buffer buffer =
session.createBuffer(SshConstants.SSH_MSG_CHANNEL_OPEN, type.length() + Integer.SIZE);
buffer.putString(type);
buffer.putInt(getId());
buffer.putInt(localWindow.getSize());
buffer.putInt(localWindow.getPacketSize());
writePacket(buffer);
return openFuture;
}