Prepare release 0.38.0

* Fix #902.

* Add test.

.gitattributes

@@ -1 +1,2 @@
 *.bat text eol=crlf
+src/itest/docker-image/** eol=lf

.github/workflows/gradle.yml

@@ -6,35 +6,37 @@ name: Build SSHJ
 
 on:
   push:
-    branches: [ master ]
   pull_request:
     branches: [ master ]
 
 jobs:
   java12:
-    name: Build with Java 12
+    name: Build with Java 11
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
-    - name: Set up JDK 12
-      uses: actions/setup-java@v1
+    - name: Set up Java 11
+      uses: actions/setup-java@v3
       with:
-        java-version: 12
+        distribution: 'temurin'
+        java-version: 11
     - name: Grant execute permission for gradlew
       run: chmod +x gradlew
     - name: Build with Gradle
       run: ./gradlew check
+    - name: Codecov
+      uses: codecov/codecov-action@v2
 
   integration:
     name: Integration test
-    needs: [java12]
-    runs-on: [ubuntu-latest]
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
-      - uses: actions/setup-java@v1
+      - uses: actions/setup-java@v3
         with:
-          java-version: 12
+          distribution: 'temurin'
+          java-version: 11
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
       - name: Build with Gradle

.github/workflows/release.yml

@@ -13,12 +13,13 @@ jobs:
     name: Build with Java 12
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
       - name: Set up JDK 12
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v2
         with:
+          distribution: 'zulu'
           java-version: 12
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
@@ -29,21 +30,20 @@ jobs:
     needs: [java12]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
-      - uses: actions/setup-java@v1
+      - uses: actions/setup-java@v2
         with:
+          distribution: 'zulu'
           java-version: 12
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
       - name: Release
-        run: ./gradlew release -Prelease.disableChecks -Prelease.pushTagsOnly -Prelease.customUsername=${{ github.actor }} -Prelease.customPassword=${{ github.token }}
+        run: ./gradlew clean publishToSonatype closeAndReleaseSonatypeStagingRepository
         env:
           ORG_GRADLE_PROJECT_signingKey: ${{ secrets.SIGNINGKEY }}
           ORG_GRADLE_PROJECT_signingKeyId: ${{ secrets.SIGNINGKEYID }}
           ORG_GRADLE_PROJECT_signingPassword: ${{ secrets.SIGNINGPASSWORD }}
           ORG_GRADLE_PROJECT_sonatypeUsername: ${{ secrets.OSSRH_USERNAME }}
           ORG_GRADLE_PROJECT_sonatypePassword: ${{ secrets.OSSRH_PASSWORD }}
-
-

README.adoc

@@ -1,7 +1,7 @@
 = sshj - SSHv2 library for Java
 Jeroen van Erp
 :sshj_groupid: com.hierynomus
-:sshj_version: 0.31.0
+:sshj_version: 0.38.0
 :source-highlighter: pygments
 
 image:https://github.com/hierynomus/sshj/actions/workflows/gradle.yml/badge.svg[link="https://github.com/hierynomus/sshj/actions/workflows/gradle.yml"]
@@ -10,6 +10,8 @@ image:https://codecov.io/gh/hierynomus/sshj/branch/master/graph/badge.svg["codec
 image:http://www.javadoc.io/badge/com.hierynomus/sshj.svg?color=blue["JavaDocs", link="http://www.javadoc.io/doc/com.hierynomus/sshj"]
 image:https://maven-badges.herokuapp.com/maven-central/com.hierynomus/sshj/badge.svg["Maven Central",link="https://maven-badges.herokuapp.com/maven-central/com.hierynomus/sshj"]
 
+WARNING: SSHJ versions up to and including 0.37.0 are vulnerable to https://nvd.nist.gov/vuln/detail/CVE-2023-48795[CVE-2023-48795 - Terrapin]. Please upgrade to 0.38.0 or higher.
+
 To get started, have a look at one of the examples. Hopefully you will find the API pleasant to work with :)
 
 == Getting SSHJ
@@ -46,7 +48,7 @@ If your project is built using another build tool that uses the Maven Central re
 In the `examples` directory, there is a separate Maven project that shows how the library can be used in some sample cases. If you want to run them, follow these guidelines:
 
 . Install http://maven.apache.org/[Maven 2.2.1] or up.
-. Clone the Overthere repository.
+. Clone the SSHJ repository.
 . Go into the `examples` directory and run the command `mvn eclipse:eclipse`.
 . Import the `examples` project into Eclipse.
 . Change the login details in the example classes (address, username and password) and run them!
@@ -95,7 +97,11 @@ If you need something that is not included, it shouldn't be too hard to add (do
 http://ssh-comparison.quendi.de/comparison.html[SSH Implementation Comparison]
 
 == Dependencies
-Java 6+. http://www.slf4j.org/download.html[slf4j] is required. http://www.bouncycastle.org/java.html[bouncycastle] is highly recommended and required for using some of the crypto algorithms. http://www.jcraft.com/jzlib/[jzlib] is required for using zlib compression.
+
+- Java 8 or higher
+- https://www.slf4j.org/[SLF4J 2.0.0]
+- https://www.bouncycastle.org[Bouncy Castle]
+
 
 == Reporting bugs
 Issue tracker: https://github.com/hierynomus/sshj/issues
@@ -104,8 +110,62 @@ Issue tracker: https://github.com/hierynomus/sshj/issues
 Fork away!
 
 == Release history
+SSHJ 0.38.0 (2024-01-02)::
+* Mitigated CVE-2023-48795 - Terrapin
+  * Merged https://github.com/hierynomus/sshj/pull/917[#917]: Implement OpenSSH strict key exchange extension
+* Merged https://github.com/hierynomus/sshj/pull/903[#903]: Fix for writing known hosts key string
+* Merged https://github.com/hierynomus/sshj/pull/913[#913]: Prevent remote port forwarding buffers to grow without bounds
+* Moved tess to JUnit5
+* Merged https://github.com/hierynomus/sshj/pull/827[#827]: Fallback to posix-rename@openssh.com extension if available
+* Merged https://github.com/hierynomus/sshj/pull/904[#904]: Add ChaCha20-Poly1305 support for OpenSSH keys
+SSHJ 0.37.0 (2023-10-11)::
+* Merged https://github.com/hierynomus/sshj/pull/899[#899]: Add support for AES-GCM OpenSSH private keys
+* Merged https://github.com/hierynomus/sshj/pull/901[#901]: Fix ZLib compression bug
+* Merged https://github.com/hierynomus/sshj/pull/898[#898]: Improved malformed file handling for OpenSSH private keys
+SSHJ 0.36.0 (2023-09-04)::
+* Rewrote Integration tests to JUnit5
+* Merged https://github.com/hierynomus/sshj/pull/851[#851]: Fix race condition in key exchange causing intermittent SSH_MSG_UNIMPLEMENTED
+* Merged https://github.com/hierynomus/sshj/pull/861[#861]: Add DefaultSecurityProviderConfig with has BouncyCastle disabled
+* Merged https://github.com/hierynomus/sshj/pull/881[#881]: Rewrote test classes to JUnit Jupiter engine
+* Merged https://github.com/hierynomus/sshj/pull/880[#880]: Removed Java 7 backport Socket utilities
+* Merged https://github.com/hierynomus/sshj/pull/879[#879]: Replaced custom Base64 with java.util.Base64
+* Merged https://github.com/hierynomus/sshj/pull/852[#852]: Removed unused bcrypt password hashing methods
+* Merged https://github.com/hierynomus/sshj/pull/874[#874]: Java 8 minimum version + dependency upgrades
+* Merged https://github.com/hierynomus/sshj/pull/876[#876]: Change `newStatefulSFTPClient` to return `StatefulSFTPClient`
+* Merged https://github.com/hierynomus/sshj/pull/860[#860]: Upgrade to Gradle 7.6.1
+* Merged https://github.com/hierynomus/sshj/pull/838[#838]: Replaced Curve25519 class with X25519 Key agreement
+* Merged https://github.com/hierynomus/sshj/pull/772[#772]: Remove dependency on jzlib
+SSHJ 0.35.0 (2023-01-30)::
+* Merged https://github.com/hierynomus/sshj/pull/835[#835]: TimeoutException message improved
+* Merged https://github.com/hierynomus/sshj/pull/815[#815]: Support authPassword on FreeBSD
+* Merged https://github.com/hierynomus/sshj/pull/813[#813]: Prevent `CHANNEL_CLOSE` between isOpen and write call.
+* Merged https://github.com/hierynomus/sshj/pull/811[#811]: Add `Transport.isKeyExchangeREquired` to prevent unnecessary KEXINIT
+SSHJ 0.34.0 (2022-08-10)::
+* Merged https://github.com/hierynomus/sshj/pull/743[#743]: Use default client credentials for AuthGssApiWithMic
+* Merged https://github.com/hierynomus/sshj/pull/801[#801]: Restore thread interrupt status after catching InterruptedException
+* Merged https://github.com/hierynomus/sshj/pull/793[#793]: Merge PKCS5 and PKCS8 classes
+* Upgraded dependencies SLF4J (1.7.36) and Logback (1.2.11)
+* Merged https://github.com/hierynomus/sshj/pull/791[#791]: Update KeepAlive examples
+* Merged https://github.com/hierynomus/sshj/pull/775[#775]: Add SFTP resume support
+SSHJ 0.33.0 (2022-04-22)::
+* Upgraded dependencies BouncyCastle (1.70)
+* Merged https://github.com/hierynomus/sshj/pull/687[#687]: Correctly close connection when remote closes connection.
+* Merged https://github.com/hierynomus/sshj/pull/741[#741]: Add support for testcontainers in test setup to test more scenarios
+* Merged https://github.com/hierynomus/sshj/pull/733[#733]: Send correct key proposal if client knows CA key
+* Merged https://github.com/hierynomus/sshj/pull/746[#746]: Fix bug in reading Putty private key file with passphrase
+* Merged https://github.com/hierynomus/sshj/pull/742[#742]: Use Config.keyAlgorithms to determine rsa-sha2 support
+* Merged https://github.com/hierynomus/sshj/pull/754[#754]: Use SFTP protocol version to set FXP rename flags conditionally
+* Merged https://github.com/hierynomus/sshj/pull/752[#752]: Correctly start and terminate KeepAlive thread
+* Merged https://github.com/hierynomus/sshj/pull/753[#753]: Provide better thread names
+* Merged https://github.com/hierynomus/sshj/pull/724[#724]: Add parameter to limit read ahead length
+* Merged https://github.com/hierynomus/sshj/pull/763[#763]: Try all public key algorithms for a specific key type
+* Merged https://github.com/hierynomus/sshj/pull/756[#756]: Remove deprecated proxy connect methods
+* Merged https://github.com/hierynomus/sshj/pull/770[#770]: Add support for `ed25519` `aes-128-cbc` keys
+* Merged https://github.com/hierynomus/sshj/pull/773[#773]: Fix NPE when reading empty OpenSSHKeyV1KeyFile
+* Merged https://github.com/hierynomus/sshj/pull/777[#777]: Don't request too many read-ahead packets
+
 SSHJ 0.32.0 (2021-10-12)::
-* Send EOF on channel close (Fixes https://github.com/hierynomus/sshj/issue/143[#143], https://github.com/hierynomus/sshj/issue/496[#496], https://github.com/hierynomus/sshj/issue/553[#553], https://github.com/hierynomus/sshj/issue/554[#554])
+* Send EOF on channel close (Fixes https://github.com/hierynomus/sshj/issues/143[#143], https://github.com/hierynomus/sshj/issues/496[#496], https://github.com/hierynomus/sshj/issues/553[#553], https://github.com/hierynomus/sshj/issues/554[#554])
 * Merged https://github.com/hierynomus/sshj/pull/726[#726]: Parse OpenSSH v1 keys with full CRT information present
 * Merged https://github.com/hierynomus/sshj/pull/721[#721]: Prefer known host key algorithm for host key verification
 * Merged https://github.com/hierynomus/sshj/pull/716[#716], https://github.com/hierynomus/sshj/pull/729[#729] and https://github.com/hierynomus/sshj/pull/730[#730]: Add full support for PuTTY v3 key files.

build-publishing.gradle

@@ -23,7 +23,6 @@ dependencies {
   compile "org.slf4j:slf4j-api:1.7.7"
   compile "org.bouncycastle:bcprov-jdk15on:$bouncycastleVersion"
   compile "org.bouncycastle:bcpkix-jdk15on:$bouncycastleVersion"
-  compile "com.jcraft:jzlib:1.1.3"
 
   testCompile "junit:junit:4.11"
   testCompile "org.mockito:mockito-core:1.9.5"

build.gradle

@@ -1,29 +1,27 @@
-import java.text.SimpleDateFormat
-import com.bmuschko.gradle.docker.tasks.container.*
-import com.bmuschko.gradle.docker.tasks.image.*
-
 plugins {
   id "java"
+  id "jvm-test-suite"
   id "groovy"
   id "jacoco"
   id "com.github.blindpirate.osgi" version '0.0.6'
   id "maven-publish"
   id "signing"
-  id 'pl.allegro.tech.build.axion-release' version '1.13.3'
-  id "com.bmuschko.docker-remote-api" version "7.1.0"
+  id 'pl.allegro.tech.build.axion-release' version '1.15.3'
   id "com.github.hierynomus.license" version "0.16.1"
-  id 'ru.vyarus.github-info' version '1.2.0'
-  id "io.github.gradle-nexus.publish-plugin" version "1.0.0"
+  id "com.bmuschko.docker-remote-api" version "9.2.1"
+  id 'ru.vyarus.github-info' version '1.5.0'
+  id "io.github.gradle-nexus.publish-plugin" version "1.3.0"
 }
 
+group = "com.hierynomus"
+ext.moduleName = "${project.group}.${project.name}"
+
+defaultTasks "build"
+
 repositories {
   mavenCentral()
 }
 
-group = "com.hierynomus"
-defaultTasks ["build"]
-ext.moduleName = "${project.group}.${project.name}"
-
 scmVersion {
   tag {
     prefix = 'v'
@@ -37,30 +35,21 @@ scmVersion {
 
 project.version = scmVersion.version
 
+compileJava {
+  options.release = 8
+}
+
 configurations.implementation.transitive = false
 
-def bouncycastleVersion = "1.69"
-def sshdVersion = "2.1.0"
+def bouncycastleVersion = "1.75"
+def sshdVersion = "2.10.0"
 
 dependencies {
-  implementation "org.slf4j:slf4j-api:1.7.32"
-  implementation "org.bouncycastle:bcprov-jdk15on:$bouncycastleVersion"
-  implementation "org.bouncycastle:bcpkix-jdk15on:$bouncycastleVersion"
-  implementation "com.jcraft:jzlib:1.1.3"
+  implementation "org.slf4j:slf4j-api:2.0.7"
+  implementation "org.bouncycastle:bcprov-jdk18on:$bouncycastleVersion"
+  implementation "org.bouncycastle:bcpkix-jdk18on:$bouncycastleVersion"
   implementation "com.hierynomus:asn-one:0.6.0"
-
   implementation "net.i2p.crypto:eddsa:0.3.0"
-
-  testImplementation "junit:junit:4.12"
-  testImplementation 'org.spockframework:spock-core:1.3-groovy-2.4'
-  testImplementation "org.mockito:mockito-core:2.28.2"
-  testImplementation "org.apache.sshd:sshd-core:$sshdVersion"
-  testImplementation "org.apache.sshd:sshd-sftp:$sshdVersion"
-  testImplementation "org.apache.sshd:sshd-scp:$sshdVersion"
-  testRuntimeOnly "ch.qos.logback:logback-classic:1.2.6"
-  testImplementation 'org.glassfish.grizzly:grizzly-http-server:2.4.4'
-  testImplementation 'org.apache.httpcomponents:httpclient:4.5.9'
-
 }
 
 license {
@@ -69,7 +58,16 @@ license {
   mapping {
     java = 'SLASHSTAR_STYLE'
   }
-  excludes(['**/djb/Curve25519.java', '**/sshj/common/Base64.java', '**/com/hierynomus/sshj/userauth/keyprovider/bcrypt/*.java'])
+  excludes([
+    '**/sshj/common/Base64.java',
+    '**/com/hierynomus/sshj/userauth/keyprovider/bcrypt/*.java',
+    '**/files/test_file_*.txt',
+  ])
+}
+
+java {
+	withJavadocJar()
+	withSourcesJar()
 }
 
 if (!JavaVersion.current().isJava9Compatible()) {
@@ -83,10 +81,82 @@ if (JavaVersion.current().isJava8Compatible()) {
   }
 }
 
-compileJava {
-  options.compilerArgs.addAll(['--release', '7'])
+testing {
+  suites {
+    configureEach {
+      useJUnitJupiter()
+      dependencies {
+        implementation "org.slf4j:slf4j-api:2.0.7"
+        implementation 'org.spockframework:spock-core:2.3-groovy-3.0'
+        implementation "org.mockito:mockito-core:4.11.0"
+        implementation "org.assertj:assertj-core:3.24.2"
+        implementation "ru.vyarus:spock-junit5:1.2.0"
+        implementation "org.apache.sshd:sshd-core:$sshdVersion"
+        implementation "org.apache.sshd:sshd-sftp:$sshdVersion"
+        implementation "org.apache.sshd:sshd-scp:$sshdVersion"
+        implementation "ch.qos.logback:logback-classic:1.3.8"
+        implementation 'org.glassfish.grizzly:grizzly-http-server:3.0.1'
+      }
+
+      targets {
+        all {
+          testTask.configure {
+            testLogging {
+              showStandardStreams = false
+              exceptionFormat = 'full'
+            }
+            include "**/*Test.*"
+            include "**/*Spec.*"
+            afterSuite { descriptor, result ->
+              def indicator = "\u001B[32m✓\u001b[0m"
+              if (result.failedTestCount > 0) {
+                indicator = "\u001B[31m✘\u001b[0m"
+              }
+              logger.lifecycle("$indicator Test ${descriptor.name}; Executed: ${result.testCount}/\u001B[32m${result.successfulTestCount}\u001B[0m/\u001B[31m${result.failedTestCount}\u001B[0m")
+            }
+          }
+        }
+      }
+    }
+
+    test {
+      sources {
+        groovy {
+          srcDirs = ['src/test/groovy']
+        }
+      }
+    }
+
+    integrationTest(JvmTestSuite) {
+      dependencies {
+        implementation project()
+        implementation 'org.testcontainers:testcontainers:1.18.3'
+        implementation 'org.testcontainers:junit-jupiter:1.18.3'
+      }
+
+      sources {
+        java {
+          srcDirs = ['src/itest/java']
+        }
+
+        resources {
+          srcDirs = ['src/itest/resources']
+        }
+      }
+
+      targets {
+        all {
+          testTask.configure {
+            shouldRunAfter(test)
+          }
+        }
+      }
+    }
+  }
 }
 
+project.tasks.compileGroovy.onlyIf { false }
+
 task writeSshjVersionProperties {
   doLast {
     project.file("${project.buildDir}/resources/main").mkdirs()
@@ -120,12 +190,6 @@ jar {
   }
 }
 
-
-java {
-	withJavadocJar()
-	withSourcesJar()
-}
-
 sourcesJar {
   manifest {
     attributes(
@@ -139,53 +203,6 @@ sourcesJar {
   }
 }
 
-configurations {
-  integrationTestImplementation.extendsFrom testImplementation
-  integrationTestRuntimeOnly.extendsFrom testRuntimeOnly
-}
-
-sourceSets {
-  integrationTest {
-    groovy {
-      compileClasspath += sourceSets.main.output + sourceSets.test.output
-      runtimeClasspath += sourceSets.main.output + sourceSets.test.output
-      srcDir file('src/itest/groovy')
-    }
-    resources.srcDir file('src/itest/resources')
-  }
-}
-
-task integrationTest(type: Test) {
-  testClassesDirs = sourceSets.integrationTest.output.classesDirs
-  classpath = sourceSets.integrationTest.runtimeClasspath
-}
-
-tasks.withType(Test) {
-  testLogging {
-    exceptionFormat = 'full'
-  }
-  include "**/*Test.*"
-  include "**/*Spec.*"
-  if (!project.hasProperty("allTests")) {
-    useJUnit {
-      excludeCategories 'com.hierynomus.sshj.test.SlowTests'
-      excludeCategories 'com.hierynomus.sshj.test.KnownFailingTests'
-    }
-  }
-
-  afterSuite { descriptor, result ->
-    if (descriptor.className != null) {
-      def indicator = "\u001B[32m✓\u001b[0m"
-      if (result.failedTestCount > 0) {
-        indicator = "\u001B[31m✘\u001b[0m"
-      }
-      logger.lifecycle("$indicator Test ${descriptor.name}; Executed: ${result.testCount}/\u001B[32m${result.successfulTestCount}\u001B[0m/\u001B[31m${result.failedTestCount}\u001B[0m")
-    }
-  }
-}
-
-project.tasks.compileGroovy.onlyIf { false }
-
 github {
   user 'hierynomus'
   license 'Apache'
@@ -271,54 +288,11 @@ nexusPublishing {
 
 jacocoTestReport {
     reports {
-        xml.enabled true
-        html.enabled true
+        xml.required = true
+        html.required = true
     }
 }
 
-
-task buildItestImage(type: DockerBuildImage) {
-    inputDir = file('src/itest/docker-image')
-    images.add('sshj/sshd-itest:latest')
-}
-
-task createItestContainer(type: DockerCreateContainer) {
-    dependsOn buildItestImage
-    targetImageId buildItestImage.getImageId()
-    hostConfig.portBindings = ['2222:22']
-    hostConfig.autoRemove = true
-}
-
-task startItestContainer(type: DockerStartContainer) {
-    dependsOn createItestContainer
-    targetContainerId createItestContainer.getContainerId()
-}
-
-task logItestContainer(type: DockerLogsContainer) {
-    dependsOn createItestContainer
-    targetContainerId createItestContainer.getContainerId()
-    showTimestamps = true
-    stdErr = true
-    stdOut = true
-    tailAll = true
-}
-
-task stopItestContainer(type: DockerStopContainer) {
-    targetContainerId createItestContainer.getContainerId()
-}
-
-task forkedUploadRelease(type: GradleBuild) {
-  buildFile = project.buildFile
-  tasks = ["clean", "publishToSonatype", "closeAndReleaseSonatypeStagingRepository"]
-}
-
-project.tasks.integrationTest.dependsOn(startItestContainer)
-project.tasks.integrationTest.finalizedBy(stopItestContainer)
-
-// Being enabled, it pollutes logs on CI. Uncomment when debugging some test to get sshd logs.
-// project.tasks.stopItestContainer.dependsOn(logItestContainer)
-
 project.tasks.release.dependsOn([project.tasks.integrationTest, project.tasks.build])
-project.tasks.release.finalizedBy(project.tasks.forkedUploadRelease)
 project.tasks.jacocoTestReport.dependsOn(project.tasks.test)
 project.tasks.check.dependsOn(project.tasks.jacocoTestReport)

examples/pom.xml

@@ -24,7 +24,7 @@
     <groupId>com.hierynomus</groupId>
     <artifactId>sshj-examples</artifactId>
     <packaging>jar</packaging>
-    <version>0.19.1</version>
+    <version>0.37.0</version>
 
     <name>sshj-examples</name>
     <description>Examples for SSHv2 library for Java</description>
@@ -55,7 +55,7 @@
         <dependency>
             <groupId>com.hierynomus</groupId>
             <artifactId>sshj</artifactId>
-            <version>0.31.0</version>
+            <version>0.33.0</version>
         </dependency>
     </dependencies>
 

examples/src/main/java/net/schmizz/sshj/examples/KeepAlive.java

@@ -19,8 +19,9 @@ public class KeepAlive {
         final SSHClient ssh = new SSHClient(defaultConfig);
         try {
             ssh.addHostKeyVerifier(new PromiscuousVerifier());
+            // Set interval to enable keep-alive before connecting
+            ssh.getConnection().getKeepAlive().setKeepAliveInterval(5);
             ssh.connect(args[0]);
-            ssh.getConnection().getKeepAlive().setKeepAliveInterval(5); //every 60sec
             ssh.authPassword(args[1], args[2]);
             Session session = ssh.startSession();
             session.allocateDefaultPTY();

examples/src/main/java/net/schmizz/sshj/examples/RemotePF.java

@@ -19,6 +19,7 @@ public class RemotePF {
         client.loadKnownHosts();
 
         client.connect("localhost");
+        client.getConnection().getKeepAlive().setKeepAliveInterval(5);
         try {
 
             client.authPublickey(System.getProperty("user.name"));
@@ -33,8 +34,6 @@ public class RemotePF {
                     // what we do with incoming connections that are forwarded to us
                     new SocketForwardingConnectListener(new InetSocketAddress("google.com", 80)));
 
-            client.getTransport().setHeartbeatInterval(30);
-
             // Something to hang on to so that the forwarding stays
             client.getTransport().join();
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright © 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,78 +17,113 @@
 #
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+APP_BASE_NAME=${0##*/}
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -97,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -105,79 +140,95 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -40,7 +40,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if "%ERRORLEVEL%" == "0" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -54,7 +54,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -64,28 +64,14 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell

src/itest/docker-image/Dockerfile

@@ -1,24 +0,0 @@
-FROM sickp/alpine-sshd:7.5-r2
-
-ADD authorized_keys /home/sshj/.ssh/authorized_keys
-
-ADD test-container/ssh_host_ecdsa_key     /etc/ssh/ssh_host_ecdsa_key
-ADD test-container/ssh_host_ecdsa_key.pub /etc/ssh/ssh_host_ecdsa_key.pub
-ADD test-container/ssh_host_ed25519_key   /etc/ssh/ssh_host_ed25519_key
-ADD test-container/ssh_host_ed25519_key.pub   /etc/ssh/ssh_host_ed25519_key.pub
-ADD test-container/sshd_config /etc/ssh/sshd_config
-COPY test-container/trusted_ca_keys /etc/ssh/trusted_ca_keys
-COPY test-container/host_keys/* /etc/ssh/
-
-RUN apk add --no-cache tini
-RUN \
-  echo "root:smile" | chpasswd && \
-  adduser -D -s /bin/ash sshj && \
-  passwd -u sshj && \
-  echo "sshj:ultrapassword" | chpasswd && \
-  chmod 600 /home/sshj/.ssh/authorized_keys && \
-  chmod 600 /etc/ssh/ssh_host_*_key && \
-  chmod 644 /etc/ssh/*.pub && \
-  chown -R sshj:sshj /home/sshj
-
-ENTRYPOINT ["/sbin/tini", "/entrypoint.sh", "-o", "LogLevel=DEBUG2"]

src/itest/docker-image/authorized_keys

@@ -3,6 +3,7 @@ ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBHQiZm0w
 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDAdJiRkkBM8yC8seTEoAn2PfwbLKrkcahZ0xxPoWICJ root@sshj
 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJ8ww4hJG/gHJYdkjTTBDF1GNz+228nuWprPV+NbQauA ajvanerp@Heimdall.local
 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOaWrwt3drIOjeBq2LSHRavxAT7ja2f+5soOUJl/zKSI ajvanerp@Heimdall.xebialabs.com
+ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAICYfPGSYFOHuSzTJ67H0ynvKJDfgDmwPOj7iJaLGbIBi sshjtest@TranceLove
 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAoZ9l6Tkm2aL1tSBy2yw4xU5s8BE9MfqS/4J7DzvsYJxF6oQmTIjmStuhH/CT7UjuDtKXdXZUsIhKtafiizxGO8kHSzKDeitpth2RSr8ddMzZKyD6RNs7MfsgjA3UTtrrSrCXEY6O43S2cnuJrWzkPxtwxaQ3zOvDbS2tiulzyq0VzYmuhA/a4CyuQtJBuu+P2oqmu6pU/VB6IzONpvBvYbNPsH1WDmP7zko5wHPihXPCliztspKxS4DRtOZ7BGXyvg44UmIy0Kf4jOkaBV/eCCA4qH7ZHz71/5ceMOpszPcNOEmLGGYhwI+P3OuGMpkrSAv1f8IY6R8spZNncP6UaQ== no-passphrase
 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDKRyZAtOJJfAhPU6xE6ZXY564vwErAI3n3Yn4lTHL9bxev9Ily6eCqPLcV0WbSV04pztngFn9MjT7yb8mcXheHpIaWEH569sMpmpOtyfn4p68SceuXBGyyPGMIcfOTknkASd1JYSD4EPkd9rZmCzcx3vEnLu8ChnA/G221xSVQ5VC/jD/c/CgNUayhQ+xbn57qHKKtZwfTa21QmwIabGYJNwlVjlKTCdddeVnZfKqKrG7cxHQApsxd21rhM9IT/C/f4Y/Tx3WUUVeam0iZ265oiPHoPALqJIWSQIUheRYAxYAQqJwSQ0Or9MM8XXun2Iy3RUSGk6eIvrCsFbNURsHNs7Pu0UnpYv6FZ3vCkFep/1pAT6fQvY7pDOOWDHKXArD4watc9gIWaQBH73wDW/KgBcnMRSoGWgQjsYqIamP4oV1+HqUI3lRAsXZaX+eiBGt3+3A5KebP27UJ1YUwhwlzs7wzTKaCu0OaL+hOsP1F2AxAa995bgFksMd23645ux3YCJKXG4sGpJ1Z/Hs49K72gv+QjLZVxXqY623c8+3OUhlixqoEFd4iG7UMc5a552ch/VA+jaspmLZoFhPz99aBRVb1oCSPxSwLw+Q/wxv6pZmT+14rqTzY2farjU53hM+CsUPh7dnWXhGG7RuA5wCdeOXOYjuksfzAoHIZhPqTgQ== ajvanerp@Heimdall.local
 ecdsa-sha2-nistp384 AAAAE2VjZHNhLXNoYTItbmlzdHAzODQAAAAIbmlzdHAzODQAAABhBMvfRYSe44VQGwxexOMibcM3+fWeUP1jrBofOxFDRRrzRF8dK/vll2svqTPXMRnITnT1UoemEcB5OHtvH4hzfh/HFeDxJ5S7UncYxoClTSa8MeMFG2Zj9CoUZs1SHbwSGg== root@sshj

src/itest/docker-image/entrypoint.sh

@@ -0,0 +1,7 @@
+#!/bin/ash
+
+# generate host keys if not present
+ssh-keygen -A
+
+# do not detach (-D), log to stderr (-e), passthrough other arguments
+exec /usr/sbin/sshd -D -e "$@"

src/itest/docker-image/test-container/sshd_config

@@ -1,158 +0,0 @@
-#	$OpenBSD: sshd_config,v 1.101 2017/03/14 07:19:07 djm Exp $
-
-# This is the sshd server system-wide configuration file.  See
-# sshd_config(5) for more information.
-
-# This sshd was compiled with PATH=/bin:/usr/bin:/sbin:/usr/sbin
-
-# The strategy used for options in the default sshd_config shipped with
-# OpenSSH is to specify options with their default value where
-# possible, but leave them commented.  Uncommented options override the
-# default value.
-
-#Port 22
-#AddressFamily any
-#ListenAddress 0.0.0.0
-#ListenAddress ::
-
-#HostKey /etc/ssh/ssh_host_rsa_key
-#HostKey /etc/ssh/ssh_host_dsa_key
-#HostKey /etc/ssh/ssh_host_ecdsa_key
-#HostKey /etc/ssh/ssh_host_ed25519_key
-
-# Ciphers and keying
-#RekeyLimit default none
-
-# Logging
-#SyslogFacility AUTH
-#LogLevel INFO
-
-# Authentication:
-
-#LoginGraceTime 2m
-PermitRootLogin yes
-#StrictModes yes
-#MaxAuthTries 6
-#MaxSessions 10
-
-#PubkeyAuthentication yes
-
-# The default is to check both .ssh/authorized_keys and .ssh/authorized_keys2
-# but this is overridden so installations will only check .ssh/authorized_keys
-AuthorizedKeysFile	.ssh/authorized_keys
-
-#AuthorizedPrincipalsFile none
-
-#AuthorizedKeysCommand none
-#AuthorizedKeysCommandUser nobody
-
-# For this to work you will also need host keys in /etc/ssh/ssh_known_hosts
-#HostbasedAuthentication no
-# Change to yes if you don't trust ~/.ssh/known_hosts for
-# HostbasedAuthentication
-#IgnoreUserKnownHosts no
-# Don't read the user's ~/.rhosts and ~/.shosts files
-#IgnoreRhosts yes
-
-# To disable tunneled clear text passwords, change to no here!
-#PasswordAuthentication yes
-#PermitEmptyPasswords no
-
-# Change to no to disable s/key passwords
-#ChallengeResponseAuthentication yes
-
-# Kerberos options
-#KerberosAuthentication no
-#KerberosOrLocalPasswd yes
-#KerberosTicketCleanup yes
-#KerberosGetAFSToken no
-
-# GSSAPI options
-#GSSAPIAuthentication no
-#GSSAPICleanupCredentials yes
-
-# Set this to 'yes' to enable PAM authentication, account processing,
-# and session processing. If this is enabled, PAM authentication will
-# be allowed through the ChallengeResponseAuthentication and
-# PasswordAuthentication.  Depending on your PAM configuration,
-# PAM authentication via ChallengeResponseAuthentication may bypass
-# the setting of "PermitRootLogin without-password".
-# If you just want the PAM account and session checks to run without
-# PAM authentication, then enable this but set PasswordAuthentication
-# and ChallengeResponseAuthentication to 'no'.
-#UsePAM no
-
-#AllowAgentForwarding yes
-#AllowTcpForwarding yes
-#GatewayPorts no
-#X11Forwarding no
-#X11DisplayOffset 10
-#X11UseLocalhost yes
-#PermitTTY yes
-#PrintMotd yes
-#PrintLastLog yes
-#TCPKeepAlive yes
-#UseLogin no
-#PermitUserEnvironment no
-#Compression delayed
-#ClientAliveInterval 0
-#ClientAliveCountMax 3
-#UseDNS no
-#PidFile /run/sshd.pid
-#MaxStartups 10:30:100
-#PermitTunnel no
-#ChrootDirectory none
-#VersionAddendum none
-
-# no default banner path
-#Banner none
-
-# override default of no subsystems
-Subsystem	sftp	/usr/lib/ssh/sftp-server
-
-# the following are HPN related configuration options
-# tcp receive buffer polling. disable in non autotuning kernels
-#TcpRcvBufPoll yes
-
-# disable hpn performance boosts
-#HPNDisabled no
-
-# buffer size for hpn to non-hpn connections
-#HPNBufferSize 2048
-
-
-# Example of overriding settings on a per-user basis
-#Match User anoncvs
-#	X11Forwarding no
-#	AllowTcpForwarding no
-#	PermitTTY no
-#	ForceCommand cvs server
-
-KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512,diffie-hellman-group14-sha256,diffie-hellman-group14-sha1,diffie-hellman-group1-sha1,diffie-hellman-group-exchange-sha1
-macs umac-64-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-256-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-ripemd160-etm@openssh.com,umac-64@openssh.com,umac-128@openssh.com,hmac-sha2-256,hmac-sha2-512,hmac-ripemd160,hmac-ripemd160@openssh.com
-
-TrustedUserCAKeys /etc/ssh/trusted_ca_keys
-
-Ciphers 3des-cbc,blowfish-cbc,aes128-cbc,aes192-cbc,aes256-cbc,aes128-ctr,aes192-ctr,aes256-ctr,aes128-gcm@openssh.com,aes256-gcm@openssh.com,chacha20-poly1305@openssh.com
-
-HostKey /etc/ssh/ssh_host_rsa_key
-HostKey /etc/ssh/ssh_host_dsa_key
-HostKey /etc/ssh/ssh_host_ecdsa_key
-HostKey /etc/ssh/ssh_host_ed25519_key
-
-HostKey /etc/ssh/ssh_host_ecdsa_256_key
-HostCertificate /etc/ssh/ssh_host_ecdsa_256_key-cert.pub
-
-HostKey /etc/ssh/ssh_host_ecdsa_384_key
-HostCertificate /etc/ssh/ssh_host_ecdsa_384_key-cert.pub
-
-HostKey /etc/ssh/ssh_host_ecdsa_521_key
-HostCertificate /etc/ssh/ssh_host_ecdsa_521_key-cert.pub
-
-HostKey /etc/ssh/ssh_host_ed25519_384_key
-HostCertificate /etc/ssh/ssh_host_ed25519_384_key-cert.pub
-
-HostKey /etc/ssh/ssh_host_rsa_2048_key
-HostCertificate /etc/ssh/ssh_host_rsa_2048_key-cert.pub
-
-LogLevel DEBUG2

src/itest/groovy/com/hierynomus/sshj/IntegrationBaseSpec.groovy

@@ -1,42 +0,0 @@
-/*
- * Copyright (C)2009 - SSHJ Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.hierynomus.sshj
-
-import net.schmizz.sshj.Config
-import net.schmizz.sshj.DefaultConfig
-import net.schmizz.sshj.SSHClient
-import net.schmizz.sshj.transport.verification.PromiscuousVerifier
-import spock.lang.Specification
-
-class IntegrationBaseSpec extends Specification {
-    protected static final int DOCKER_PORT = 2222
-    protected static final String USERNAME = "sshj"
-    protected static final String KEYFILE = "src/itest/resources/keyfiles/id_rsa"
-    protected final static String SERVER_IP = System.getProperty("serverIP", "127.0.0.1")
-
-    protected static SSHClient getConnectedClient(Config config) {
-        SSHClient sshClient = new SSHClient(config)
-        sshClient.addHostKeyVerifier(new PromiscuousVerifier())
-        sshClient.connect(SERVER_IP, DOCKER_PORT)
-
-        return sshClient
-    }
-
-    protected static SSHClient getConnectedClient() throws IOException {
-        return getConnectedClient(new DefaultConfig())
-    }
-
-}

src/itest/groovy/com/hierynomus/sshj/IntegrationSpec.groovy

@@ -1,95 +0,0 @@
-/*
- * Copyright (C)2009 - SSHJ Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.hierynomus.sshj
-
-import com.hierynomus.sshj.key.KeyAlgorithms
-import net.schmizz.sshj.DefaultConfig
-import net.schmizz.sshj.SSHClient
-import net.schmizz.sshj.transport.TransportException
-import net.schmizz.sshj.userauth.UserAuthException
-import spock.lang.Unroll
-
-class IntegrationSpec extends IntegrationBaseSpec {
-
-    @Unroll
-    def "should accept correct key for #signatureName"() {
-        given:
-        def config = new DefaultConfig()
-        config.setKeyAlgorithms(Collections.singletonList(signatureFactory))
-        SSHClient sshClient = new SSHClient(config)
-        sshClient.addHostKeyVerifier(fingerprint) // test-containers/ssh_host_ecdsa_key's fingerprint
-
-        when:
-        sshClient.connect(SERVER_IP, DOCKER_PORT)
-
-        then:
-        sshClient.isConnected()
-
-        where:
-        signatureFactory << [KeyAlgorithms.ECDSASHANistp256(), KeyAlgorithms.EdDSA25519()]
-        fingerprint << ["d3:6a:a9:52:05:ab:b5:48:dd:73:60:18:0c:3a:f0:a3", "dc:68:38:ce:fc:6f:2c:d6:6d:6b:34:eb:5c:f0:41:6a"]
-        signatureName = signatureFactory.getName()
-    }
-
-    def "should decline wrong key"() throws IOException {
-        given:
-        SSHClient sshClient = new SSHClient(new DefaultConfig())
-        sshClient.addHostKeyVerifier("d4:6a:a9:52:05:ab:b5:48:dd:73:60:18:0c:3a:f0:a3")
-
-        when:
-        sshClient.connect(SERVER_IP, DOCKER_PORT)
-
-        then:
-        thrown(TransportException.class)
-    }
-
-    @Unroll
-    def "should authenticate with key #key"() {
-        given:
-        SSHClient client = getConnectedClient()
-
-        when:
-        def keyProvider = passphrase != null ? client.loadKeys("src/itest/resources/keyfiles/$key", passphrase) : client.loadKeys("src/itest/resources/keyfiles/$key")
-        client.authPublickey(USERNAME, keyProvider)
-
-        then:
-        client.isAuthenticated()
-
-        where:
-        key | passphrase
-//        "id_ecdsa_nistp256" | null // TODO: Need to improve PKCS8 key support.
-        "id_ecdsa_opensshv1" | null
-        "id_ed25519_opensshv1" | null
-        "id_ed25519_opensshv1_aes256cbc.pem" | "foobar"
-        "id_ed25519_opensshv1_protected" | "sshjtest"
-        "id_rsa" | null
-        "id_rsa_opensshv1" | null
-        "id_ecdsa_nistp384_opensshv1" | null
-        "id_ecdsa_nistp521_opensshv1" | null
-    }
-
-   def "should not authenticate with wrong key"() {
-        given:
-        SSHClient client = getConnectedClient()
-
-        when:
-        client.authPublickey("sshj", "src/itest/resources/keyfiles/id_unknown_key")
-
-        then:
-        thrown(UserAuthException.class)
-        !client.isAuthenticated()
-    }
-}

src/itest/groovy/com/hierynomus/sshj/sftp/FileWriteSpec.groovy

@@ -1,68 +0,0 @@
-/*
- * Copyright (C)2009 - SSHJ Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.hierynomus.sshj.sftp
-
-import com.hierynomus.sshj.IntegrationBaseSpec
-import net.schmizz.sshj.SSHClient
-import net.schmizz.sshj.sftp.OpenMode
-import net.schmizz.sshj.sftp.RemoteFile
-import net.schmizz.sshj.sftp.SFTPClient
-
-import java.nio.charset.StandardCharsets
-
-import static org.codehaus.groovy.runtime.IOGroovyMethods.withCloseable
-
-class FileWriteSpec extends IntegrationBaseSpec {
-
-    def "should append to file (GH issue #390)"() {
-        given:
-        SSHClient client = getConnectedClient()
-        client.authPublickey("sshj", "src/test/resources/id_rsa")
-        SFTPClient sftp = client.newSFTPClient()
-        def file = "/home/sshj/test.txt"
-        def initialText = "This is the initial text.\n".getBytes(StandardCharsets.UTF_16)
-        def appendText = "And here's the appended text.\n".getBytes(StandardCharsets.UTF_16)
-
-        when:
-        withCloseable(sftp.open(file, EnumSet.of(OpenMode.WRITE, OpenMode.CREAT))) { RemoteFile initial ->
-            initial.write(0, initialText, 0, initialText.length)
-        }
-
-        then:
-        withCloseable(sftp.open(file, EnumSet.of(OpenMode.READ))) { RemoteFile read ->
-            def bytes = new byte[initialText.length]
-            read.read(0, bytes, 0, bytes.length)
-            bytes == initialText
-        }
-
-        when:
-        withCloseable(sftp.open(file, EnumSet.of(OpenMode.WRITE, OpenMode.APPEND))) { RemoteFile append ->
-            append.write(0, appendText, 0, appendText.length)
-        }
-
-        then:
-        withCloseable(sftp.open(file, EnumSet.of(OpenMode.READ))) { RemoteFile read ->
-            def bytes = new byte[initialText.length + appendText.length]
-            read.read(0, bytes, 0, bytes.length)
-            Arrays.copyOfRange(bytes, 0, initialText.length) == initialText
-            Arrays.copyOfRange(bytes, initialText.length, initialText.length + appendText.length) == appendText
-        }
-
-        cleanup:
-        sftp.close()
-        client.close()
-    }
-}

src/itest/groovy/com/hierynomus/sshj/signature/KeyWithCertificateSpec.groovy

@@ -1,115 +0,0 @@
-/*
- * Copyright (C)2009 - SSHJ Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.hierynomus.sshj.signature
-
-import com.hierynomus.sshj.IntegrationBaseSpec
-import net.schmizz.sshj.DefaultConfig
-import net.schmizz.sshj.SSHClient
-import net.schmizz.sshj.transport.verification.OpenSSHKnownHosts
-import spock.lang.Unroll
-
-import java.nio.file.Files
-import java.util.stream.Collectors
-
-/**
- * This is a brief test for verifying connection to a server using keys with certificates.
- *
- * Also, take a look at the unit test {@link net.schmizz.sshj.transport.verification.KeyWithCertificateUnitSpec}.
- */
-class KeyWithCertificateSpec extends IntegrationBaseSpec {
-
-    @Unroll
-    def "authorising with a signed public key #keyName"() {
-        given:
-        def client = getConnectedClient()
-
-        when:
-        client.authPublickey(USERNAME, "src/itest/resources/keyfiles/certificates/$keyName")
-
-        then:
-        client.authenticated
-
-        where:
-        keyName << [
-                "id_ecdsa_256_pem_signed_by_ecdsa",
-                "id_ecdsa_256_rfc4716_signed_by_ecdsa",
-                "id_ecdsa_256_pem_signed_by_ed25519",
-                "id_ecdsa_256_rfc4716_signed_by_ed25519",
-                "id_ecdsa_256_pem_signed_by_rsa",
-                "id_ecdsa_256_rfc4716_signed_by_rsa",
-                "id_ecdsa_384_pem_signed_by_ecdsa",
-                "id_ecdsa_384_rfc4716_signed_by_ecdsa",
-                "id_ecdsa_384_pem_signed_by_ed25519",
-                "id_ecdsa_384_rfc4716_signed_by_ed25519",
-                "id_ecdsa_384_pem_signed_by_rsa",
-                "id_ecdsa_384_rfc4716_signed_by_rsa",
-                "id_ecdsa_521_pem_signed_by_ecdsa",
-                "id_ecdsa_521_rfc4716_signed_by_ecdsa",
-                "id_ecdsa_521_pem_signed_by_ed25519",
-                "id_ecdsa_521_rfc4716_signed_by_ed25519",
-                "id_ecdsa_521_pem_signed_by_rsa",
-                "id_ecdsa_521_rfc4716_signed_by_rsa",
-                "id_rsa_2048_pem_signed_by_ecdsa",
-                "id_rsa_2048_rfc4716_signed_by_ecdsa",
-                "id_rsa_2048_pem_signed_by_ed25519",
-                "id_rsa_2048_rfc4716_signed_by_ed25519",
-                "id_rsa_2048_pem_signed_by_rsa",
-                "id_rsa_2048_rfc4716_signed_by_rsa",
-                "id_ed25519_384_rfc4716_signed_by_ecdsa",
-                "id_ed25519_384_rfc4716_signed_by_ed25519",
-                "id_ed25519_384_rfc4716_signed_by_rsa",
-        ]
-    }
-
-    @Unroll
-    def "accepting a signed host public key with type #hostKeyAlgo"() {
-        given:
-        File knownHosts = Files.createTempFile("known_hosts", "").toFile()
-        knownHosts.deleteOnExit()
-
-        and:
-        File caPubKey = new File("src/itest/resources/keyfiles/certificates/CA_rsa.pem.pub")
-        String knownHostsFileContents = "" +
-                "@cert-authority $SERVER_IP ${caPubKey.text}" +
-                "\n@cert-authority [$SERVER_IP]:$DOCKER_PORT ${caPubKey.text}"
-        knownHosts.write(knownHostsFileContents)
-
-        and:
-        def config = new DefaultConfig()
-        config.keyAlgorithms = config.keyAlgorithms.stream()
-                .filter { it.name == hostKeyAlgo }
-                .collect(Collectors.toList())
-        SSHClient sshClient = new SSHClient(config)
-        sshClient.addHostKeyVerifier(new OpenSSHKnownHosts(knownHosts))
-        sshClient.connect(SERVER_IP, DOCKER_PORT)
-
-        when:
-        sshClient.authPassword("sshj", "ultrapassword")
-
-        then:
-        sshClient.authenticated
-
-        and:
-        knownHosts.getText() == knownHostsFileContents
-
-        where:
-        hostKeyAlgo << [
-                "ecdsa-sha2-nistp256-cert-v01@openssh.com",
-                "ssh-ed25519-cert-v01@openssh.com",
-                "ssh-rsa-cert-v01@openssh.com",
-        ]
-    }
-}

src/itest/groovy/com/hierynomus/sshj/signature/SignatureSpec.groovy

@@ -1,42 +0,0 @@
-/*
- * Copyright (C)2009 - SSHJ Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.hierynomus.sshj.signature
-
-import com.hierynomus.sshj.IntegrationBaseSpec
-import com.hierynomus.sshj.key.KeyAlgorithms
-import net.schmizz.sshj.DefaultConfig
-import spock.lang.Unroll
-
-class SignatureSpec extends IntegrationBaseSpec {
-
-    @Unroll
-    def "should correctly connect with #sig Signature"() {
-        given:
-        def cfg = new DefaultConfig()
-        cfg.setKeyAlgorithms(Collections.singletonList(sigFactory))
-        def client = getConnectedClient(cfg)
-
-        when:
-        client.authPublickey(USERNAME, KEYFILE)
-
-        then:
-        client.authenticated
-
-        where:
-        sigFactory << [KeyAlgorithms.SSHRSA(), KeyAlgorithms.RSASHA256(), KeyAlgorithms.RSASHA512()]
-        sig = sigFactory.name
-    }
-}

src/itest/groovy/com/hierynomus/sshj/transport/cipher/CipherSpec.groovy

@@ -1,55 +0,0 @@
-/*
- * Copyright (C)2009 - SSHJ Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.hierynomus.sshj.transport.cipher
-
-import com.hierynomus.sshj.IntegrationBaseSpec
-import net.schmizz.sshj.DefaultConfig
-import spock.lang.Unroll
-
-class CipherSpec extends IntegrationBaseSpec {
-
-    @Unroll
-    def "should correctly connect with #cipher Cipher"() {
-        given:
-        def cfg = new DefaultConfig()
-        cfg.setCipherFactories(cipherFactory)
-        def client = getConnectedClient(cfg)
-
-        when:
-        client.authPublickey(USERNAME, KEYFILE)
-
-        then:
-        client.authenticated
-
-        cleanup:
-        client.disconnect()
-
-        where:
-        cipherFactory << [BlockCiphers.TripleDESCBC(),
-                          BlockCiphers.BlowfishCBC(),
-                          BlockCiphers.AES128CBC(),
-                          BlockCiphers.AES128CTR(),
-                          BlockCiphers.AES192CBC(),
-                          BlockCiphers.AES192CTR(),
-                          BlockCiphers.AES256CBC(),
-                          BlockCiphers.AES256CTR(),
-                          GcmCiphers.AES128GCM(),
-                          GcmCiphers.AES256GCM(),
-                          ChachaPolyCiphers.CHACHA_POLY_OPENSSH()]
-        cipher = cipherFactory.name
-    }
-
-}

src/itest/groovy/com/hierynomus/sshj/transport/kex/KexSpec.groovy

@@ -1,61 +0,0 @@
-/*
- * Copyright (C)2009 - SSHJ Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.hierynomus.sshj.transport.kex
-
-import com.hierynomus.sshj.IntegrationBaseSpec
-import com.hierynomus.sshj.transport.mac.Macs
-import net.schmizz.sshj.DefaultConfig
-import net.schmizz.sshj.transport.kex.Curve25519DH
-import net.schmizz.sshj.transport.kex.Curve25519SHA256
-import net.schmizz.sshj.transport.kex.DH
-import net.schmizz.sshj.transport.kex.DHGexSHA1
-import net.schmizz.sshj.transport.kex.DHGexSHA256
-import net.schmizz.sshj.transport.kex.ECDH
-import net.schmizz.sshj.transport.kex.ECDHNistP
-import spock.lang.Unroll
-
-class KexSpec extends IntegrationBaseSpec {
-
-    @Unroll
-    def "should correctly connect with #kex Key Exchange"() {
-        given:
-        def cfg = new DefaultConfig()
-        cfg.setKeyExchangeFactories(kexFactory)
-        def client = getConnectedClient(cfg)
-
-        when:
-        client.authPublickey(USERNAME, KEYFILE)
-
-        then:
-        client.authenticated
-
-        where:
-        kexFactory << [DHGroups.Group1SHA1(),
-                       DHGroups.Group14SHA1(),
-                       DHGroups.Group14SHA256(),
-                       DHGroups.Group16SHA512(),
-                       DHGroups.Group18SHA512(),
-                       new DHGexSHA1.Factory(),
-                       new DHGexSHA256.Factory(),
-                       new Curve25519SHA256.Factory(),
-                       new Curve25519SHA256.FactoryLibSsh(),
-                       new ECDHNistP.Factory256(),
-                       new ECDHNistP.Factory384(),
-                       new ECDHNistP.Factory521()]
-        kex = kexFactory.name
-    }
-
-}

src/itest/groovy/com/hierynomus/sshj/transport/mac/MacSpec.groovy

@@ -1,65 +0,0 @@
-/*
- * Copyright (C)2009 - SSHJ Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.hierynomus.sshj.transport.mac
-
-import com.hierynomus.sshj.IntegrationBaseSpec
-import net.schmizz.sshj.DefaultConfig
-import spock.lang.Unroll
-
-class MacSpec extends IntegrationBaseSpec {
-
-    @Unroll
-    def "should correctly connect with #mac MAC"() {
-        given:
-        def cfg = new DefaultConfig()
-        cfg.setMACFactories(macFactory)
-        def client = getConnectedClient(cfg)
-
-        when:
-        client.authPublickey(USERNAME, KEYFILE)
-
-        then:
-        client.authenticated
-
-        cleanup:
-        client.disconnect()
-
-        where:
-        macFactory << [Macs.HMACRIPEMD160(), Macs.HMACRIPEMD160OpenSsh(), Macs.HMACSHA2256(), Macs.HMACSHA2512()]
-        mac = macFactory.name
-    }
-
-    @Unroll
-    def "should correctly connect with Encrypt-Then-Mac #mac MAC"() {
-        given:
-        def cfg = new DefaultConfig()
-        cfg.setMACFactories(macFactory)
-        def client = getConnectedClient(cfg)
-
-        when:
-        client.authPublickey(USERNAME, KEYFILE)
-
-        then:
-        client.authenticated
-
-        cleanup:
-        client.disconnect()
-
-        where:
-        macFactory << [Macs.HMACRIPEMD160Etm(), Macs.HMACSHA2256Etm(), Macs.HMACSHA2512Etm()]
-        mac = macFactory.name
-    }
-}

src/itest/java/com/hierynomus/sshj/HostKeyVerifierTest.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj;
+
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import com.hierynomus.sshj.key.KeyAlgorithms;
+
+import net.schmizz.sshj.Config;
+import net.schmizz.sshj.DefaultConfig;
+import net.schmizz.sshj.SSHClient;
+import net.schmizz.sshj.transport.TransportException;
+
+@Testcontainers
+public class HostKeyVerifierTest {
+    @Container
+    private static final SshdContainer sshd = new SshdContainer();
+
+    public static Stream<Arguments> signatureAlgos() {
+        return Stream.of(
+            Arguments.of(KeyAlgorithms.ECDSASHANistp256(), "d3:6a:a9:52:05:ab:b5:48:dd:73:60:18:0c:3a:f0:a3"),
+            Arguments.of(KeyAlgorithms.EdDSA25519(), "dc:68:38:ce:fc:6f:2c:d6:6d:6b:34:eb:5c:f0:41:6a"));
+    }
+
+    @ParameterizedTest(name = "Should connect with signature verified for Key Algorithm {0}")
+    @MethodSource("signatureAlgos")
+    public void shouldConnectWithSignatureVerified(KeyAlgorithms.Factory alg, String fingerprint) throws Throwable {
+        Config config = new DefaultConfig();
+        config.setKeyAlgorithms(List.of(alg));
+
+        try (SSHClient client = new SSHClient(config)) {
+            client.addHostKeyVerifier(fingerprint);
+            client.connect(sshd.getHost(), sshd.getFirstMappedPort());
+
+            assertTrue(client.isConnected());
+        }
+    }
+
+    @Test
+    public void shouldDeclineWrongKey() throws Throwable {
+        try (SSHClient client = new SSHClient()) {
+            assertThrows(TransportException.class, () -> {
+                client.addHostKeyVerifier("d4:6a:a9:52:05:ab:b5:48:dd:73:60:18:0c:3a:f0:a3");
+                client.connect(sshd.getHost(), sshd.getFirstMappedPort());
+            });
+        }
+    }
+}

src/itest/java/com/hierynomus/sshj/ManyChannelsTest.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.jupiter.api.Test;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import com.hierynomus.sshj.SshdContainer.SshdConfigBuilder;
+
+import net.schmizz.sshj.SSHClient;
+import net.schmizz.sshj.common.IOUtils;
+import net.schmizz.sshj.connection.channel.direct.Session;
+
+import static org.assertj.core.api.Assertions.*;
+
+@Testcontainers
+public class ManyChannelsTest {
+    @Container
+    private static final SshdContainer sshd = new SshdContainer(SshdContainer.Builder.defaultBuilder()
+            .withSshdConfig(SshdConfigBuilder.defaultBuilder().with("MaxSessions", "200")).withAllKeys());
+
+    @Test
+    public void shouldWorkWithManyChannelsWithoutNoExistentChannelError_GH805() throws Throwable {
+        try (SSHClient client = sshd.getConnectedClient()) {
+            client.authPublickey("sshj", "src/test/resources/id_rsa");
+
+            List<Future<Exception>> futures = new ArrayList<>();
+            ExecutorService executorService = Executors.newCachedThreadPool();
+
+            for (int i = 0; i < 20; i++) {
+                futures.add(executorService.submit(() -> {
+                    try {
+                        for (int j = 0; j < 10; j++) {
+                            try (Session sshSession = client.startSession()) {
+                                try (Session.Command sshCommand = sshSession.exec("ls -la")) {
+                                    IOUtils.readFully(sshCommand.getInputStream()).toString();
+                                }
+                            }
+                        }
+                    } catch (Exception e) {
+                        return e;
+                    }
+                    return null;
+                }));
+            }
+
+            executorService.shutdown();
+            executorService.awaitTermination(1, TimeUnit.DAYS);
+
+            assertThat(futures).allSatisfy(future -> assertThat(future.get()).isNull());
+        }
+    }
+}

src/itest/java/com/hierynomus/sshj/PublicKeyAuthTest.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import com.hierynomus.sshj.SshdContainer.SshdConfigBuilder;
+
+import net.schmizz.sshj.SSHClient;
+import net.schmizz.sshj.userauth.UserAuthException;
+import net.schmizz.sshj.userauth.keyprovider.KeyProvider;
+
+@Testcontainers
+public class PublicKeyAuthTest {
+    @Container
+    private static final SshdContainer sshd = new SshdContainer(SshdContainer.Builder.defaultBuilder().withSshdConfig(
+            SshdConfigBuilder.defaultBuilder().with("PubkeyAcceptedAlgorithms", "+ssh-rsa-cert-v01@openssh.com"))
+            .withAllKeys());
+
+    public static Stream<Arguments> keys() {
+        return Stream.of(
+                Arguments.of("id_rsa2", null),
+                // "id_ecdsa_nistp256" | null // TODO: Need to improve PKCS8 key support.
+                Arguments.of("id_ecdsa_opensshv1", null),
+                Arguments.of("id_ed25519_opensshv1", null),
+                Arguments.of("id_ed25519_opensshv1_aes256cbc.pem", "foobar"),
+                Arguments.of("id_ed25519_opensshv1_aes128cbc.pem", "sshjtest"),
+                Arguments.of("id_ed25519_opensshv1_protected", "sshjtest"),
+                Arguments.of("id_rsa", null),
+                Arguments.of("id_rsa_opensshv1", null),
+                Arguments.of("id_ecdsa_nistp384_opensshv1", null),
+                Arguments.of("id_ecdsa_nistp521_opensshv1", null));
+    }
+
+    @ParameterizedTest(name = "should authenticate with signed public key {0}")
+    @MethodSource("keys")
+    public void shouldAuthenticateWithSignedRsaKey(String key, String passphrase) throws Throwable {
+        try (SSHClient client = sshd.getConnectedClient()) {
+            KeyProvider p = null;
+            if (passphrase != null) {
+                p = client.loadKeys("src/itest/resources/keyfiles/" + key, passphrase);
+            } else {
+                p = client.loadKeys("src/itest/resources/keyfiles/" + key);
+            }
+            client.authPublickey("sshj", p);
+
+            assertTrue(client.isAuthenticated());
+        }
+    }
+
+    @Test
+    public void shouldNotAuthenticateWithUnknownKey() throws Throwable {
+        try (SSHClient client = sshd.getConnectedClient()) {
+            assertThrows(UserAuthException.class, () -> {
+                client.authPublickey("sshj", "src/itest/resources/keyfiles/id_unknown_key");
+            });
+
+            assertFalse(client.isAuthenticated());
+        }
+    }
+
+}

src/itest/java/com/hierynomus/sshj/RsaShaKeySignatureTest.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj;
+
+import java.util.stream.Stream;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import com.hierynomus.sshj.SshdContainer.SshdConfigBuilder;
+import com.hierynomus.sshj.key.KeyAlgorithms;
+
+import net.schmizz.sshj.Config;
+import net.schmizz.sshj.DefaultConfig;
+import net.schmizz.sshj.SSHClient;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static com.hierynomus.sshj.SshdContainer.withSshdContainer;
+
+public class RsaShaKeySignatureTest {
+
+    public static Stream<Arguments> hostKeysAndAlgorithms() {
+        return Stream.of(
+                Arguments.of("ssh_host_ecdsa_256_key", KeyAlgorithms.ECDSASHANistp256()),
+                Arguments.of("ssh_host_ecdsa_384_key", KeyAlgorithms.ECDSASHANistp384()),
+                Arguments.of("ssh_host_ecdsa_521_key", KeyAlgorithms.ECDSASHANistp521()),
+                Arguments.of("ssh_host_ed25519_384_key", KeyAlgorithms.EdDSA25519()),
+                Arguments.of("ssh_host_rsa_2048_key", KeyAlgorithms.RSASHA512()));
+    }
+
+    @ParameterizedTest(name = "Should connect to server that does not support ssh-rsa with host key {1}")
+    @MethodSource("hostKeysAndAlgorithms")
+    public void shouldConnectToServerThatDoesNotSupportSshRsaWithHostKey(String key, KeyAlgorithms.Factory algorithm)
+            throws Throwable {
+        SshdConfigBuilder configBuilder = SshdConfigBuilder
+                .defaultBuilder()
+                .with("PubkeyAcceptedAlgorithms", "rsa-sha2-512,rsa-sha2-256,ssh-ed25519");
+        withSshdContainer(SshdContainer.Builder.defaultBuilder()
+                .withSshdConfig(configBuilder).addHostKey("test-container/host_keys/" + key), sshd -> {
+                    Config c = new DefaultConfig();
+                    c.setKeyAlgorithms(List.of(KeyAlgorithms.RSASHA512(), KeyAlgorithms.RSASHA256(), algorithm));
+
+                    SSHClient client = sshd.getConnectedClient(c);
+                    client.authPublickey("sshj", "src/itest/resources/keyfiles/id_rsa_opensshv1");
+
+                    assertTrue(client.isAuthenticated());
+
+                    client.disconnect();
+                });
+    }
+
+    @ParameterizedTest(name = "Should connect to a default server with host key {1} with a default config")
+    @MethodSource("hostKeysAndAlgorithms")
+    public void shouldConnectToDefaultServer(String key, KeyAlgorithms.Factory algorithm) throws Throwable {
+        withSshdContainer(SshdContainer.Builder.defaultBuilder().addHostKey("test-container/host_keys/" + key),
+                sshd -> {
+                    SSHClient client = sshd.getConnectedClient();
+                    client.authPublickey("sshj", "src/itest/resources/keyfiles/id_rsa_opensshv1");
+
+                    assertTrue(client.isAuthenticated());
+
+                    client.disconnect();
+                });
+    }
+
+    @ParameterizedTest(name = "Should connect to a server that only supports ssh-rsa with host key {1}")
+    @MethodSource("hostKeysAndAlgorithms")
+    public void shouldConnectToSshRsaOnlyServer(String key, KeyAlgorithms.Factory algorithm) throws Throwable {
+        SshdConfigBuilder configBuilder = SshdConfigBuilder
+                .defaultBuilder()
+                .with("PubkeyAcceptedAlgorithms", "ssh-rsa,ssh-ed25519");
+
+        withSshdContainer(SshdContainer.Builder.defaultBuilder()
+                .withSshdConfig(configBuilder).addHostKey("test-container/host_keys/" + key), sshd -> {
+                    Config c = new DefaultConfig();
+                    c.setKeyAlgorithms(List.of(KeyAlgorithms.SSHRSA(), algorithm));
+                    SSHClient client = sshd.getConnectedClient(c);
+                    client.authPublickey("sshj", "src/itest/resources/keyfiles/id_rsa_opensshv1");
+
+                    assertTrue(client.isAuthenticated());
+                    client.disconnect();
+                });
+    }
+}

src/itest/java/com/hierynomus/sshj/SshServerWaitStrategy.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj;
+
+import org.testcontainers.containers.wait.strategy.WaitStrategy;
+import org.testcontainers.containers.wait.strategy.WaitStrategyTarget;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.Arrays;
+
+/**
+ * A wait strategy designed for {@link SshdContainer} to wait until the SSH server is ready, to avoid races when a test
+ * tries to connect to a server before the server has started.
+ */
+public class SshServerWaitStrategy implements WaitStrategy {
+    private Duration startupTimeout = Duration.ofMinutes(1);
+
+    @Override
+    public void waitUntilReady(WaitStrategyTarget waitStrategyTarget) {
+        long expectedEnd = System.nanoTime() + startupTimeout.toNanos();
+        while (waitStrategyTarget.isRunning()) {
+            long attemptStart = System.nanoTime();
+            IOException error = null;
+            byte[] buffer = new byte[7];
+            try (Socket socket = new Socket()) {
+                socket.setSoTimeout(500);
+                socket.connect(new InetSocketAddress(
+                        waitStrategyTarget.getHost(), waitStrategyTarget.getFirstMappedPort()));
+                // Haven't seen any SSH server that sends the version in two or more packets.
+                //noinspection ResultOfMethodCallIgnored
+                socket.getInputStream().read(buffer);
+                if (!Arrays.equals(buffer, "SSH-2.0".getBytes(StandardCharsets.UTF_8))) {
+                    error = new IOException("The version message doesn't look like an SSH server version");
+                }
+            } catch (IOException err) {
+                error = err;
+            }
+
+            if (error == null) {
+                break;
+            } else if (System.nanoTime() >= expectedEnd) {
+                throw new RuntimeException(error);
+            }
+
+            try {
+                //noinspection BusyWait
+                Thread.sleep(Math.max(0L, 500L - (System.nanoTime() - attemptStart) / 1_000_000));
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                break;
+            }
+        }
+    }
+
+    @Override
+    public WaitStrategy withStartupTimeout(Duration startupTimeout) {
+        this.startupTimeout = startupTimeout;
+        return this;
+    }
+}

src/itest/java/com/hierynomus/sshj/SshdContainer.java

@@ -0,0 +1,246 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+import net.schmizz.sshj.Config;
+import net.schmizz.sshj.DefaultConfig;
+import net.schmizz.sshj.SSHClient;
+import net.schmizz.sshj.transport.verification.PromiscuousVerifier;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.jupiter.api.function.ThrowingConsumer;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+import org.testcontainers.images.builder.dockerfile.DockerfileBuilder;
+import org.testcontainers.utility.DockerLoggerFactory;
+
+import java.util.function.Consumer;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Future;
+
+/**
+ * A JUnit4 rule for launching a generic SSH server container.
+ */
+public class SshdContainer extends GenericContainer<SshdContainer> {
+
+    /**
+     * A workaround for strange logger names of testcontainers. They contain no
+     * dots, but contain slashes,
+     * square brackets, and even emoji. It's uneasy to set the logging level via the
+     * XML file of logback, the
+     * result would be less readable than the code below.
+     */
+    public static class DebugLoggingImageFromDockerfile extends ImageFromDockerfile {
+        public DebugLoggingImageFromDockerfile() {
+            super();
+            Logger logger = (Logger) LoggerFactory.getILoggerFactory()
+                    .getLogger(DockerLoggerFactory.getLogger(getDockerImageName()).getName());
+            logger.setLevel(Level.DEBUG);
+        }
+    }
+
+    public static class SshdConfigBuilder {
+        public static final String DEFAULT_SSHD_CONFIG = "" +
+                "PermitRootLogin yes\n" +
+                "AuthorizedKeysFile .ssh/authorized_keys\n" +
+                "Subsystem sftp /usr/lib/ssh/sftp-server\n" +
+                "KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512,diffie-hellman-group14-sha256,diffie-hellman-group14-sha1,diffie-hellman-group1-sha1,diffie-hellman-group-exchange-sha1\n"
+                +
+                "macs umac-64-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-256-etm@openssh.com,hmac-sha2-512-etm@openssh.com,umac-64@openssh.com,umac-128@openssh.com,hmac-sha2-256,hmac-sha2-512\n"
+                +
+                "TrustedUserCAKeys /etc/ssh/trusted_ca_keys\n" +
+                "Ciphers 3des-cbc,aes128-cbc,aes192-cbc,aes256-cbc,aes128-ctr,aes192-ctr,aes256-ctr,aes128-gcm@openssh.com,aes256-gcm@openssh.com,chacha20-poly1305@openssh.com\n"
+                +
+                "LogLevel DEBUG2\n";
+        private String sshdConfig;
+
+        public SshdConfigBuilder(@NotNull String sshdConfig) {
+            this.sshdConfig = sshdConfig;
+        }
+
+        public static SshdConfigBuilder defaultBuilder() {
+            return new SshdConfigBuilder(DEFAULT_SSHD_CONFIG);
+        }
+
+        public @NotNull SshdConfigBuilder withHostKey(@NotNull String hostKey) {
+            sshdConfig += "HostKey /etc/ssh/" + Paths.get(hostKey).getFileName() + "\n";
+            return this;
+        }
+
+        public @NotNull SshdConfigBuilder withHostKeyCertificate(@NotNull String hostKeyCertificate) {
+            sshdConfig += "HostCertificate /etc/ssh/" + Paths.get(hostKeyCertificate).getFileName() + "\n";
+            return this;
+        }
+
+        public @NotNull SshdConfigBuilder with(String key, String value) {
+            sshdConfig += key + " " + value + "\n";
+            return this;
+        }
+
+        public @NotNull String build() {
+            return sshdConfig;
+        }
+    }
+
+    public static class Builder implements Consumer<DockerfileBuilder> {
+        private List<String> hostKeys = new ArrayList<>();
+        private List<String> certificates = new ArrayList<>();
+        private @NotNull SshdConfigBuilder sshdConfig = SshdConfigBuilder.defaultBuilder();
+
+        public static Builder defaultBuilder() {
+            Builder b = new Builder();
+
+            return b;
+        }
+
+
+        public @NotNull Builder withSshdConfig(@NotNull SshdConfigBuilder sshdConfig) {
+            this.sshdConfig = sshdConfig;
+            return this;
+        }
+
+        public @NotNull Builder withAllKeys() {
+            this.addHostKey("test-container/ssh_host_ecdsa_key");
+            this.addHostKey("test-container/ssh_host_ed25519_key");
+            this.addHostKey("test-container/host_keys/ssh_host_ecdsa_256_key");
+            this.addHostKey("test-container/host_keys/ssh_host_ecdsa_384_key");
+            this.addHostKey("test-container/host_keys/ssh_host_ecdsa_521_key");
+            this.addHostKey("test-container/host_keys/ssh_host_ed25519_384_key");
+            this.addHostKey("test-container/host_keys/ssh_host_rsa_2048_key");
+            this.addHostKeyCertificate("test-container/host_keys/ssh_host_ecdsa_256_key-cert.pub");
+            this.addHostKeyCertificate("test-container/host_keys/ssh_host_ecdsa_384_key-cert.pub");
+            this.addHostKeyCertificate("test-container/host_keys/ssh_host_ecdsa_521_key-cert.pub");
+            this.addHostKeyCertificate("test-container/host_keys/ssh_host_ed25519_384_key-cert.pub");
+            this.addHostKeyCertificate("test-container/host_keys/ssh_host_rsa_2048_key-cert.pub");
+            return this;
+        }
+
+        public @NotNull SshdContainer build() {
+            return new SshdContainer(buildInner());
+        }
+
+        @NotNull Future<String> buildInner() {
+            return new DebugLoggingImageFromDockerfile()
+                    .withDockerfileFromBuilder(this)
+                    .withFileFromPath(".", Paths.get("src/itest/docker-image"))
+                    .withFileFromString("sshd_config", sshdConfig.build());
+        }
+
+        @Override
+        public void accept(@NotNull DockerfileBuilder builder) {
+            builder.from("alpine:3.19.0");
+            builder.run("apk add --no-cache openssh");
+            builder.expose(22);
+            builder.copy("entrypoint.sh", "/entrypoint.sh");
+
+            builder.add("authorized_keys", "/home/sshj/.ssh/authorized_keys");
+            builder.copy("test-container/trusted_ca_keys", "/etc/ssh/trusted_ca_keys");
+
+            for (String hostKey : hostKeys) {
+                builder.copy(hostKey, "/etc/ssh/" + Paths.get(hostKey).getFileName());
+                builder.copy(hostKey + ".pub", "/etc/ssh/" + Paths.get(hostKey).getFileName() + ".pub");
+            }
+
+            for (String certificate : certificates) {
+                builder.copy(certificate, "/etc/ssh/" + Paths.get(certificate).getFileName());
+            }
+
+
+            builder.run("apk add --no-cache tini"
+                    + " && echo \"root:smile\" | chpasswd"
+                    + " && adduser -D -s /bin/ash sshj"
+                    + " && passwd -u sshj"
+                    + " && echo \"sshj:ultrapassword\" | chpasswd"
+                    + " && chmod 600 /home/sshj/.ssh/authorized_keys"
+                    + " && chmod 600 /etc/ssh/ssh_host_*_key"
+                    + " && chmod 644 /etc/ssh/*.pub"
+                    + " && chmod 755 /entrypoint.sh"
+                    + " && chown -R sshj:sshj /home/sshj");
+            builder.entryPoint("/sbin/tini", "/entrypoint.sh", "-o", "LogLevel=DEBUG2");
+
+            builder.add("sshd_config", "/etc/ssh/sshd_config");
+        }
+
+        public @NotNull Builder addHostKey(@NotNull String hostKey) {
+            hostKeys.add(hostKey);
+            sshdConfig.withHostKey(hostKey);
+            return this;
+        }
+
+        public @NotNull Builder addHostKeyCertificate(@NotNull String hostKeyCertificate) {
+            certificates.add(hostKeyCertificate);
+            sshdConfig.withHostKeyCertificate(hostKeyCertificate);
+            return this;
+        }
+    }
+
+    @SuppressWarnings("unused") // Used dynamically by Spock
+    public SshdContainer() {
+        this(new SshdContainer.Builder().withAllKeys().buildInner());
+    }
+
+    public SshdContainer(SshdContainer.Builder builder) {
+        this(builder.buildInner());
+    }
+
+    public SshdContainer(@NotNull Future<String> future) {
+        super(future);
+        withExposedPorts(22);
+        setWaitStrategy(new SshServerWaitStrategy());
+        withLogConsumer(outputFrame -> {
+            switch (outputFrame.getType()) {
+                case STDOUT:
+                    logger().info("sshd stdout: {}", outputFrame.getUtf8String().stripTrailing());
+                    break;
+                case STDERR:
+                    logger().info("sshd stderr: {}", outputFrame.getUtf8String().stripTrailing());
+                    break;
+                case END:
+                    break;
+
+            }
+        });
+    }
+
+    public SSHClient getConnectedClient(Config config) throws IOException {
+        SSHClient sshClient = new SSHClient(config);
+        sshClient.addHostKeyVerifier(new PromiscuousVerifier());
+        sshClient.connect("127.0.0.1", getFirstMappedPort());
+
+        return sshClient;
+    }
+
+    public SSHClient getConnectedClient() throws IOException {
+        return getConnectedClient(new DefaultConfig());
+    }
+
+    public static void withSshdContainer(SshdContainer.Builder builder, @NotNull ThrowingConsumer<SshdContainer> consumer) throws Throwable {
+        SshdContainer sshdContainer = new SshdContainer(builder.buildInner());
+        sshdContainer.start();
+        try {
+            consumer.accept(sshdContainer);
+        } finally {
+            sshdContainer.stop();
+        }
+    }
+}

src/itest/java/com/hierynomus/sshj/sftp/FileWriteTest.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj.sftp;
+
+import java.nio.charset.StandardCharsets;
+import java.util.EnumSet;
+
+import org.junit.jupiter.api.Test;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+import org.testcontainers.shaded.org.bouncycastle.util.Arrays;
+
+import com.hierynomus.sshj.SshdContainer;
+
+import net.schmizz.sshj.SSHClient;
+import net.schmizz.sshj.sftp.OpenMode;
+import net.schmizz.sshj.sftp.RemoteFile;
+import net.schmizz.sshj.sftp.SFTPClient;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@Testcontainers
+public class FileWriteTest {
+    @Container
+    private static SshdContainer sshd = new SshdContainer();
+
+    @Test
+    public void shouldAppendToFile_GH390() throws Throwable {
+        try (SSHClient client = sshd.getConnectedClient()) {
+            client.authPublickey("sshj", "src/test/resources/id_rsa");
+            try (SFTPClient sftp = client.newSFTPClient()) {
+                String file = "/home/sshj/test.txt";
+                byte[] initialText = "This is the initial text.\n".getBytes(StandardCharsets.UTF_16);
+                byte[] appendText = "And here's the appended text.\n".getBytes(StandardCharsets.UTF_16);
+
+                try (RemoteFile initial = sftp.open(file, EnumSet.of(OpenMode.WRITE, OpenMode.CREAT))) {
+                    initial.write(0, initialText, 0, initialText.length);
+                }
+
+                try (RemoteFile read = sftp.open(file, EnumSet.of(OpenMode.READ))) {
+                    byte[] readBytes = new byte[initialText.length];
+                    read.read(0, readBytes, 0, readBytes.length);
+                    assertThat(readBytes).isEqualTo(initialText);
+                }
+
+                try (RemoteFile initial = sftp.open(file, EnumSet.of(OpenMode.WRITE, OpenMode.APPEND))) {
+                    initial.write(0, appendText, 0, appendText.length);
+                }
+
+                try (RemoteFile read = sftp.open(file, EnumSet.of(OpenMode.READ))) {
+                    byte[] readBytes = new byte[initialText.length + appendText.length];
+                    read.read(0, readBytes, 0, readBytes.length);
+                    assertThat(Arrays.copyOfRange(readBytes, 0, initialText.length)).isEqualTo(initialText);
+                    assertThat(Arrays.copyOfRange(readBytes, initialText.length, initialText.length + appendText.length)).isEqualTo(appendText);
+                }
+            }
+
+        }
+    }
+}

src/itest/java/com/hierynomus/sshj/sftp/PutFileCompressedTest.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj.sftp;
+
+import com.hierynomus.sshj.SshdContainer;
+import net.schmizz.sshj.SSHClient;
+import net.schmizz.sshj.sftp.SFTPClient;
+import net.schmizz.sshj.xfer.InMemorySourceFile;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Random;
+
+@Testcontainers
+public class PutFileCompressedTest {
+
+    private static class TestInMemorySourceFile extends InMemorySourceFile {
+
+        private final String name;
+        private final byte[] data;
+
+        public TestInMemorySourceFile(String name, byte[] data) {
+            this.name = name;
+            this.data = data;
+        }
+
+        @Override
+        public String getName() {
+            return name;
+        }
+
+        @Override
+        public long getLength() {
+            return data.length;
+        }
+
+        @Override
+        public InputStream getInputStream() throws IOException {
+            return new ByteArrayInputStream(data);
+        }
+
+    }
+
+    @Container
+    private static SshdContainer sshd = new SshdContainer();
+
+    @Test
+    public void shouldPutCompressedFile_GH893() throws Throwable {
+        try (SSHClient client = sshd.getConnectedClient()) {
+            client.authPublickey("sshj", "src/test/resources/id_rsa");
+            client.useCompression();
+            try (SFTPClient sftp = client.newSFTPClient()) {
+                String filename = "test.txt";
+                // needs to be a larger file for bug taking effect
+                byte[] content = new byte[5000];
+                Random r = new Random(1);
+                r.nextBytes(content);
+
+                sftp.put(new TestInMemorySourceFile(filename,content), "/home/sshj/");
+            }
+
+        }
+    }
+}

src/itest/java/com/hierynomus/sshj/signature/HostKeyWithCertificateTest.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj.signature;
+
+import java.io.File;
+import java.io.StringReader;
+import java.nio.file.Files;
+import java.util.List;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import com.hierynomus.sshj.SshdContainer;
+import com.hierynomus.sshj.SshdContainer.SshdConfigBuilder;
+
+import net.schmizz.sshj.DefaultConfig;
+import net.schmizz.sshj.SSHClient;
+import net.schmizz.sshj.transport.verification.OpenSSHKnownHosts;
+
+import static com.hierynomus.sshj.SshdContainer.withSshdContainer;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class HostKeyWithCertificateTest {
+
+    @ParameterizedTest(name = "Should connect to server that has a signed host public key {0}")
+    @ValueSource(strings = { "ssh_host_ecdsa_256_key", "ssh_host_ecdsa_384_key", "ssh_host_ecdsa_521_key",
+            "ssh_host_ed25519_384_key" })
+    // TODO "ssh_host_rsa_2048_key" fails with "HOST_KEY_NOT_VERIFIABLE" after upgrade to new OpenSSH version
+    public void shouldConnectToServerWithSignedHostKey(String hostkey) throws Throwable {
+        File caPubKey = new File("src/itest/resources/keyfiles/certificates/CA_rsa.pem.pub");
+        String caPubKeyContents = Files.readString(caPubKey.toPath());
+        String address = "127.0.0.1";
+
+        SshdConfigBuilder b = SshdConfigBuilder.defaultBuilder().with("PasswordAuthentication", "yes");
+
+        withSshdContainer(SshdContainer.Builder.defaultBuilder().withSshdConfig(b).addHostKey("test-container/host_keys/" + hostkey).addHostKeyCertificate("test-container/host_keys/" + hostkey + "-cert.pub"), sshd -> {
+            String knownHosts = List.of("@cert-authority " + address + " " + caPubKeyContents,
+                    "@cert-authority [" + address + "]:" + sshd.getFirstMappedPort() + " " + caPubKeyContents).stream()
+                    .reduce("", (a, b1) -> a + "\n" + b1);
+            DefaultConfig cfg = new DefaultConfig();
+            try (SSHClient c = new SSHClient(cfg)) {
+                c.addHostKeyVerifier(new OpenSSHKnownHosts(new StringReader(knownHosts)));
+                c.connect(address, sshd.getFirstMappedPort());
+
+                c.authPassword("sshj", "ultrapassword");
+
+                assertTrue(c.isAuthenticated());
+            }
+        });
+
+    }
+}

src/itest/java/com/hierynomus/sshj/signature/PublicKeyAuthWithCertificateTest.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj.signature;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.stream.Stream;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import com.hierynomus.sshj.SshdContainer;
+import com.hierynomus.sshj.SshdContainer.SshdConfigBuilder;
+
+import net.schmizz.sshj.Config;
+import net.schmizz.sshj.DefaultConfig;
+import net.schmizz.sshj.SSHClient;
+
+@Testcontainers
+public class PublicKeyAuthWithCertificateTest {
+    @Container
+    private static final SshdContainer sshd = new SshdContainer(SshdContainer.Builder.defaultBuilder().withSshdConfig(SshdConfigBuilder.defaultBuilder().with("PubkeyAcceptedAlgorithms", "+ssh-rsa-cert-v01@openssh.com")).withAllKeys());
+
+    public static Stream<String> keys() {
+        return Stream.of(
+        "id_ecdsa_256_pem_signed_by_ecdsa",
+        "id_ecdsa_256_rfc4716_signed_by_ecdsa",
+        "id_ecdsa_256_pem_signed_by_ed25519",
+        "id_ecdsa_256_rfc4716_signed_by_ed25519",
+        "id_ecdsa_256_pem_signed_by_rsa",
+        "id_ecdsa_256_rfc4716_signed_by_rsa",
+        "id_ecdsa_384_pem_signed_by_ecdsa",
+        "id_ecdsa_384_rfc4716_signed_by_ecdsa",
+        "id_ecdsa_384_pem_signed_by_ed25519",
+        "id_ecdsa_384_rfc4716_signed_by_ed25519",
+        "id_ecdsa_384_pem_signed_by_rsa",
+        "id_ecdsa_384_rfc4716_signed_by_rsa",
+        "id_ecdsa_521_pem_signed_by_ecdsa",
+        "id_ecdsa_521_rfc4716_signed_by_ecdsa",
+        "id_ecdsa_521_pem_signed_by_ed25519",
+        "id_ecdsa_521_rfc4716_signed_by_ed25519",
+        "id_ecdsa_521_pem_signed_by_rsa",
+        "id_ecdsa_521_rfc4716_signed_by_rsa",
+        "id_rsa_2048_pem_signed_by_ecdsa",
+        "id_rsa_2048_rfc4716_signed_by_ecdsa",
+        "id_rsa_2048_pem_signed_by_ed25519",
+        "id_rsa_2048_rfc4716_signed_by_ed25519",
+        "id_rsa_2048_pem_signed_by_rsa",
+        "id_rsa_2048_rfc4716_signed_by_rsa",
+        "id_ed25519_384_rfc4716_signed_by_ecdsa",
+        "id_ed25519_384_rfc4716_signed_by_ed25519",
+        "id_ed25519_384_rfc4716_signed_by_rsa");
+    }
+
+    @ParameterizedTest(name = "should authenticate with signed public key {0}")
+    @MethodSource("keys")
+    public void shouldAuthenticateWithSignedPublicKey(String key) throws Throwable {
+        Config c = new DefaultConfig();
+        SSHClient client = sshd.getConnectedClient(c);
+
+        client.authPublickey("sshj", "src/itest/resources/keyfiles/certificates/" + key);
+
+        assertTrue(client.isAuthenticated());
+
+        client.disconnect();
+    }
+
+}

src/itest/java/com/hierynomus/sshj/signature/SignatureTest.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj.signature;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import com.hierynomus.sshj.SshdContainer;
+import com.hierynomus.sshj.SshdContainer.SshdConfigBuilder;
+import com.hierynomus.sshj.key.KeyAlgorithms;
+
+import net.schmizz.sshj.Config;
+import net.schmizz.sshj.DefaultConfig;
+import net.schmizz.sshj.SSHClient;
+
+@Testcontainers
+public class SignatureTest {
+    @Container
+    private static final SshdContainer sshd = new SshdContainer(SshdContainer.Builder.defaultBuilder().withSshdConfig(SshdConfigBuilder.defaultBuilder().with("HostKeyAlgorithms", "+ssh-rsa").with("PubkeyAcceptedAlgorithms", "+ssh-rsa")).withAllKeys());
+
+    public static Stream<KeyAlgorithms.Factory> algs() {
+        return Stream.of(KeyAlgorithms.SSHRSA(), KeyAlgorithms.RSASHA256(), KeyAlgorithms.RSASHA512());
+    }
+
+    @ParameterizedTest(name = "should correctly connect with Signature {0}")
+    @MethodSource("algs")
+    public void shouldCorrectlyConnectWithMac(KeyAlgorithms.Factory alg) throws Throwable {
+        Config c = new DefaultConfig();
+        c.setKeyAlgorithms(List.of(alg));
+        try (SSHClient client = sshd.getConnectedClient(c)) {
+            client.authPublickey("sshj", "src/itest/resources/keyfiles/id_rsa");
+
+            assertTrue(client.isAuthenticated());
+        }
+    }
+
+}

src/itest/java/com/hierynomus/sshj/transport/cipher/CipherTest.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj.transport.cipher;
+
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import com.hierynomus.sshj.SshdContainer;
+
+import net.schmizz.sshj.Config;
+import net.schmizz.sshj.DefaultConfig;
+import net.schmizz.sshj.SSHClient;
+import net.schmizz.sshj.common.Factory;
+import net.schmizz.sshj.transport.cipher.Cipher;
+
+@Testcontainers
+public class CipherTest {
+    @Container
+    private static final SshdContainer sshd = new SshdContainer();
+
+    public static Stream<Factory.Named<Cipher>> ciphers() {
+        return Stream.of(BlockCiphers.TripleDESCBC(),
+                          BlockCiphers.AES128CBC(),
+                          BlockCiphers.AES128CTR(),
+                          BlockCiphers.AES192CBC(),
+                          BlockCiphers.AES192CTR(),
+                          BlockCiphers.AES256CBC(),
+                          BlockCiphers.AES256CTR(),
+                          GcmCiphers.AES128GCM(),
+                          GcmCiphers.AES256GCM(),
+                          ChachaPolyCiphers.CHACHA_POLY_OPENSSH());
+    }
+
+    @ParameterizedTest(name = "should correctly connect with Cipher {0}")
+    @MethodSource("ciphers")
+    public void shouldCorrectlyConnectWithCipher(Factory.Named<Cipher> cipher) throws Throwable {
+        Config c = new DefaultConfig();
+        c.setCipherFactories(List.of(cipher));
+        try (SSHClient client = sshd.getConnectedClient(c)) {
+            client.authPublickey("sshj", "src/itest/resources/keyfiles/id_rsa_opensshv1");
+
+            assertTrue(client.isAuthenticated());
+        }
+    }
+}

src/itest/java/com/hierynomus/sshj/transport/kex/KexTest.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj.transport.kex;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import com.hierynomus.sshj.SshdContainer;
+
+import net.schmizz.sshj.Config;
+import net.schmizz.sshj.DefaultConfig;
+import net.schmizz.sshj.SSHClient;
+import net.schmizz.sshj.common.Factory;
+import net.schmizz.sshj.transport.kex.Curve25519SHA256;
+import net.schmizz.sshj.transport.kex.DHGexSHA1;
+import net.schmizz.sshj.transport.kex.DHGexSHA256;
+import net.schmizz.sshj.transport.kex.ECDHNistP;
+import net.schmizz.sshj.transport.kex.KeyExchange;
+
+@Testcontainers
+public class KexTest {
+    @Container
+    private static final SshdContainer sshd = new SshdContainer();
+
+    public static Stream<Factory.Named<KeyExchange>> kex() {
+        return Stream.of(
+                DHGroups.Group1SHA1(),
+                DHGroups.Group14SHA1(),
+                DHGroups.Group14SHA256(),
+                DHGroups.Group16SHA512(),
+                DHGroups.Group18SHA512(),
+                new DHGexSHA1.Factory(),
+                new DHGexSHA256.Factory(),
+                new Curve25519SHA256.Factory(),
+                new Curve25519SHA256.FactoryLibSsh(),
+                new ECDHNistP.Factory256(),
+                new ECDHNistP.Factory384(),
+                new ECDHNistP.Factory521());
+    }
+
+    @ParameterizedTest(name = "should correctly connect with Key Exchange {0}")
+    @MethodSource("kex")
+    public void shouldCorrectlyConnectWithMac(Factory.Named<KeyExchange> kex) throws Throwable {
+        Config c = new DefaultConfig();
+        c.setKeyExchangeFactories(List.of(kex));
+        try (SSHClient client = sshd.getConnectedClient(c)) {
+            client.authPublickey("sshj", "src/itest/resources/keyfiles/id_rsa_opensshv1");
+
+            assertTrue(client.isAuthenticated());
+        }
+    }
+}

src/itest/java/com/hierynomus/sshj/transport/kex/StrictKeyExchangeTest.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj.transport.kex;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.read.ListAppender;
+import com.hierynomus.sshj.SshdContainer;
+import net.schmizz.sshj.SSHClient;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@Testcontainers
+class StrictKeyExchangeTest {
+
+    @Container
+    private static final SshdContainer sshd = new SshdContainer();
+
+    private final List<Logger> watchedLoggers = new ArrayList<>();
+    private final ListAppender<ILoggingEvent> logWatcher = new ListAppender<>();
+
+    @BeforeEach
+    void setUpLogWatcher() {
+        logWatcher.start();
+        setUpLogger("net.schmizz.sshj.transport.Decoder");
+        setUpLogger("net.schmizz.sshj.transport.Encoder");
+        setUpLogger("net.schmizz.sshj.transport.KeyExchanger");
+    }
+
+    @AfterEach
+    void tearDown() {
+        watchedLoggers.forEach(Logger::detachAndStopAllAppenders);
+    }
+
+    private void setUpLogger(String className) {
+        Logger logger = ((Logger) LoggerFactory.getLogger(className));
+        logger.addAppender(logWatcher);
+        watchedLoggers.add(logger);
+    }
+
+    @Test
+    void strictKeyExchange() throws Throwable {
+        try (SSHClient client = sshd.getConnectedClient()) {
+            client.authPublickey("sshj", "src/itest/resources/keyfiles/id_rsa_opensshv1");
+            assertTrue(client.isAuthenticated());
+        }
+        List<String> keyExchangerLogs = getLogs("KeyExchanger");
+        assertThat(keyExchangerLogs).containsSequence(
+            "Initiating key exchange",
+            "Sending SSH_MSG_KEXINIT",
+            "Received SSH_MSG_KEXINIT",
+            "Enabling strict key exchange extension"
+        );
+        List<String> decoderLogs = getLogs("Decoder").stream()
+            .map(log -> log.split(":")[0])
+            .collect(Collectors.toList());
+        assertThat(decoderLogs).containsExactly(
+            "Received packet #0",
+            "Received packet #1",
+            "Received packet #2",
+            "Received packet #0",
+            "Received packet #1",
+            "Received packet #2",
+            "Received packet #3"
+        );
+        List<String> encoderLogs = getLogs("Encoder").stream()
+            .map(log -> log.split(":")[0])
+            .collect(Collectors.toList());
+        assertThat(encoderLogs).containsExactly(
+            "Encoding packet #0",
+            "Encoding packet #1",
+            "Encoding packet #2",
+            "Encoding packet #0",
+            "Encoding packet #1",
+            "Encoding packet #2",
+            "Encoding packet #3"
+        );
+    }
+
+    private List<String> getLogs(String className) {
+        return logWatcher.list.stream()
+            .filter(event -> event.getLoggerName().endsWith(className))
+            .map(ILoggingEvent::getFormattedMessage)
+            .collect(Collectors.toList());
+    }
+
+}

src/itest/java/com/hierynomus/sshj/transport/mac/MacTest.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj.transport.mac;
+
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import com.hierynomus.sshj.SshdContainer;
+
+import net.schmizz.sshj.Config;
+import net.schmizz.sshj.DefaultConfig;
+import net.schmizz.sshj.SSHClient;
+
+@Testcontainers
+public class MacTest {
+    @Container
+    private static final SshdContainer sshd = new SshdContainer();
+
+    public static Stream<Macs.Factory> macs() {
+        return Stream.of(Macs.HMACSHA2256(), Macs.HMACSHA2512(), Macs.HMACSHA2256Etm(), Macs.HMACSHA2512Etm());
+    }
+
+    @ParameterizedTest(name = "should correctly connect with MAC {0}")
+    @MethodSource("macs")
+    public void shouldCorrectlyConnectWithMac(Macs.Factory mac) throws Throwable {
+        Config c = new DefaultConfig();
+        c.setMACFactories(List.of(mac));
+        try (SSHClient client = sshd.getConnectedClient(c)) {
+            client.authPublickey("sshj", "src/itest/resources/keyfiles/id_rsa_opensshv1");
+
+            assertTrue(client.isAuthenticated());
+        }
+    }
+}

src/itest/resources/keyfiles/id_ed25519_opensshv1_aes128cbc.pem

@@ -0,0 +1,3 @@
+-----BEGIN OPENSSH PRIVATE KEY-----
+b3BlbnNzaC1rZXktdjEAAAAACmFlczEyOC1jYmMAAAAGYmNyeXB0AAAAGAAAABDfrL8SxDyrkNlsJdAmc7Z0AAAAEAAAAAEAAAAzAAAAC3NzaC1lZDI1NTE5AAAAICYfPGSYFOHuSzTJ67H0ynvKJDfgDmwPOj7iJaLGbIBiAAAAkLVqaDIfs+sPBNyy7ytdLnP/xH7Nt5FIXx3Upw6wKuMGdBzbFQLcvu60Le+SFP3uUfXE8TcHramXbH0n+UBMW6raCAKOkHUU1BtrKxPG1eKU/LBx3Bk5FxyKm7fo0XsCUmqSVK25EHOJfYq1QwIbWICkvQUNu+2Hg8/MQKoFJMentI+GqjdaG76f6Wf+aj9UwA==
+-----END OPENSSH PRIVATE KEY-----

src/itest/resources/logback-test.xml

@@ -0,0 +1,34 @@
+<!--
+
+    Copyright (C)2009 - SSHJ Contributors
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+<configuration>
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%.-20thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="info">
+        <appender-ref ref="STDOUT"/>
+    </root>
+
+    <logger name="org.apache.sshd.server" level="debug" />
+    <logger name="net.schmizz.sshj" level="debug"/>
+    <logger name="net.schmizz.sshj.transport" level="trace" />
+
+</configuration>

src/main/java/com/hierynomus/sshj/backport/Jdk7HttpProxySocket.java

@@ -1,78 +0,0 @@
-/*
- * Copyright (C)2009 - SSHJ Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.hierynomus.sshj.backport;
-
-import net.schmizz.sshj.common.IOUtils;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.*;
-
-public class Jdk7HttpProxySocket extends Socket {
-
-    private Proxy httpProxy = null;
-
-    public Jdk7HttpProxySocket(Proxy proxy) {
-        super(proxy.type() == Proxy.Type.HTTP ? Proxy.NO_PROXY : proxy);
-        if (proxy.type() == Proxy.Type.HTTP) {
-            this.httpProxy = proxy;
-        }
-    }
-
-    @Override
-    public void connect(SocketAddress endpoint, int timeout) throws IOException {
-        if (httpProxy != null) {
-            connectHttpProxy(endpoint, timeout);
-        } else {
-            super.connect(endpoint, timeout);
-        }
-    }
-
-    private void connectHttpProxy(SocketAddress endpoint, int timeout) throws IOException {
-        super.connect(httpProxy.address(), timeout);
-
-        if (!(endpoint instanceof InetSocketAddress)) {
-            throw new SocketException("Expected an InetSocketAddress to connect to, got: " + endpoint);
-        }
-        InetSocketAddress isa = (InetSocketAddress) endpoint;
-        String httpConnect = "CONNECT " + isa.getHostName() + ":" + isa.getPort() + " HTTP/1.0\n\n";
-        getOutputStream().write(httpConnect.getBytes(IOUtils.UTF8));
-        checkAndFlushProxyResponse();
-    }
-
-    private void checkAndFlushProxyResponse()throws IOException {
-        InputStream socketInput = getInputStream();
-        byte[] tmpBuffer = new byte[512];
-        int len = socketInput.read(tmpBuffer, 0, tmpBuffer.length);
-
-        if (len == 0) {
-            throw new SocketException("Empty response from proxy");
-        }
-
-        String proxyResponse = new String(tmpBuffer, 0, len, IOUtils.UTF8);
-
-        // Expecting HTTP/1.x 200 OK
-        if (proxyResponse.contains("200")) {
-            // Flush any outstanding message in buffer
-            if (socketInput.available() > 0) {
-                socketInput.skip(socketInput.available());
-            }
-            // Proxy Connect Successful
-        } else {
-            throw new SocketException("Fail to create Socket\nResponse was:" + proxyResponse);
-        }
-    }
-}

src/main/java/com/hierynomus/sshj/backport/Sockets.java

@@ -1,41 +0,0 @@
-/*
- * Copyright (C)2009 - SSHJ Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.hierynomus.sshj.backport;
-
-import java.io.Closeable;
-import java.io.IOException;
-import java.net.Socket;
-
-public class Sockets {
-
-    /**
-     * Java 7 and up have Socket implemented as Closeable, whereas Java6 did not have this inheritance.
-     * @param socket The socket to wrap as Closeable
-     * @return The (potentially wrapped) Socket as a Closeable.
-     */
-    public static Closeable asCloseable(final Socket socket) {
-        if (Closeable.class.isAssignableFrom(socket.getClass())) {
-            return Closeable.class.cast(socket);
-        } else {
-            return new Closeable() {
-                @Override
-                public void close() throws IOException {
-                    socket.close();
-                }
-            };
-        }
-    }
-}

src/main/java/com/hierynomus/sshj/common/RemoteAddressProvider.java

@@ -13,14 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.hierynomus.sshj.backport;
+package com.hierynomus.sshj.common;
 
-public class JavaVersion {
-    public static boolean isJava7OrEarlier() {
-        String property = System.getProperty("java.specification.version");
-        float diff = Float.parseFloat(property) - 1.7f;
-
-        return diff < 0.01;
-    }
+import java.net.InetSocketAddress;
 
+public interface RemoteAddressProvider {
+    /**
+     * Get Remote Socket Address associated with transport connection
+     *
+     * @return Remote Socket Address or null when not connected
+     */
+    InetSocketAddress getRemoteSocketAddress();
 }

src/main/java/com/hierynomus/sshj/common/ThreadNameProvider.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hierynomus.sshj.common;
+
+import java.net.InetSocketAddress;
+
+public class ThreadNameProvider {
+    private static final String DISCONNECTED = "DISCONNECTED";
+
+    /**
+     * Set Thread Name prefixed with sshj followed by class and remote address when connected
+     *
+     * @param thread Class of Thread being named
+     * @param remoteAddressProvider Remote Address Provider associated with Thread
+     */
+    public static void setThreadName(final Thread thread, final RemoteAddressProvider remoteAddressProvider) {
+        final InetSocketAddress remoteSocketAddress = remoteAddressProvider.getRemoteSocketAddress();
+        final String address = remoteSocketAddress == null ? DISCONNECTED : remoteSocketAddress.toString();
+        final long started = System.currentTimeMillis();
+        final String threadName = String.format("sshj-%s-%s-%d", thread.getClass().getSimpleName(), address, started);
+        thread.setName(threadName);
+    }
+}

src/main/java/com/hierynomus/sshj/key/KeyAlgorithms.java

@@ -22,13 +22,8 @@ import net.schmizz.sshj.signature.SignatureDSA;
 import net.schmizz.sshj.signature.SignatureECDSA;
 import net.schmizz.sshj.signature.SignatureRSA;
 
-import java.util.Arrays;
-import java.util.List;
-
 public class KeyAlgorithms {
 
-    public static List<String> SSH_RSA_SHA2_ALGORITHMS = Arrays.asList("rsa-sha2-512", "rsa-sha2-256");
-
     public static Factory SSHRSA() { return new Factory("ssh-rsa", new SignatureRSA.FactorySSHRSA(), KeyType.RSA); }
     public static Factory SSHRSACertV01() { return new Factory("ssh-rsa-cert-v01@openssh.com", new SignatureRSA.FactoryCERT(), KeyType.RSA_CERT); }
     public static Factory RSASHA256() { return new Factory("rsa-sha2-256", new SignatureRSA.FactoryRSASHA256(), KeyType.RSA); }
@@ -61,9 +56,18 @@ public class KeyAlgorithms {
             return algorithmName;
         }
 
+        public KeyType getKeyType() {
+            return keyType;
+        }
+
         @Override
         public KeyAlgorithm create() {
             return new BaseKeyAlgorithm(algorithmName, signatureFactory, keyType);
         }
+
+        @Override
+        public String toString() {
+            return algorithmName;
+        }
     }
 }

src/main/java/com/hierynomus/sshj/transport/cipher/ChachaPolyCipher.java

@@ -16,9 +16,8 @@
 package com.hierynomus.sshj.transport.cipher;
 
 import java.security.GeneralSecurityException;
-import java.security.InvalidAlgorithmParameterException;
-import java.security.InvalidKeyException;
 
+import java.security.MessageDigest;
 import java.security.spec.AlgorithmParameterSpec;
 import java.util.Arrays;
 import javax.crypto.spec.IvParameterSpec;
@@ -82,8 +81,7 @@ public class ChachaPolyCipher extends BaseCipher {
     }
 
     @Override
-    protected void initCipher(javax.crypto.Cipher cipher, Mode mode, byte[] key, byte[] iv)
-            throws InvalidKeyException, InvalidAlgorithmParameterException {
+    protected void initCipher(javax.crypto.Cipher cipher, Mode mode, byte[] key, byte[] iv) {
         this.mode = mode;
 
         cipherKey = getKeySpec(Arrays.copyOfRange(key, 0, CHACHA_KEY_SIZE));
@@ -127,28 +125,34 @@ public class ChachaPolyCipher extends BaseCipher {
 
     @Override
     public void update(byte[] input, int inputOffset, int inputLen) {
-        if (inputOffset != AAD_LENGTH) {
+        if (inputOffset != 0 && inputOffset != AAD_LENGTH) {
             throw new IllegalArgumentException("updateAAD called with inputOffset " + inputOffset);
         }
 
-        final int macInputLength = AAD_LENGTH + inputLen;
-
+        final int macInputLength = inputOffset + inputLen;
         if (mode == Mode.Decrypt) {
-            byte[] macInput = new byte[macInputLength];
-            System.arraycopy(encryptedAad, 0, macInput, 0, AAD_LENGTH);
-            System.arraycopy(input, AAD_LENGTH, macInput, AAD_LENGTH, inputLen);
+            final byte[] macInput = new byte[macInputLength];
 
-            byte[] expectedPolyTag = mac.doFinal(macInput);
-            byte[] actualPolyTag = Arrays.copyOfRange(input, macInputLength, macInputLength + POLY_TAG_LENGTH);
-            if (!Arrays.equals(actualPolyTag, expectedPolyTag)) {
+            if (inputOffset == 0) {
+                // Handle decryption without AAD
+                System.arraycopy(input, 0, macInput, 0, inputLen);
+            } else {
+                // Handle decryption with previous AAD from updateAAD()
+                System.arraycopy(encryptedAad, 0, macInput, 0, AAD_LENGTH);
+                System.arraycopy(input, AAD_LENGTH, macInput, AAD_LENGTH, inputLen);
+            }
+
+            final byte[] expectedPolyTag = mac.doFinal(macInput);
+            final byte[] actualPolyTag = Arrays.copyOfRange(input, macInputLength, macInputLength + POLY_TAG_LENGTH);
+            if (!MessageDigest.isEqual(actualPolyTag, expectedPolyTag)) {
                 throw new SSHRuntimeException("MAC Error");
             }
         }
 
         try {
-            cipher.update(input, AAD_LENGTH, inputLen, input, AAD_LENGTH);
+            cipher.update(input, inputOffset, inputLen, input, inputOffset);
         } catch (GeneralSecurityException e) {
-            throw new SSHRuntimeException("Error updating data through cipher", e);
+            throw new SSHRuntimeException("ChaCha20 cipher processing failed", e);
         }
 
         if (mode == Mode.Encrypt) {

src/main/java/com/hierynomus/sshj/transport/kex/DHGroups.java

@@ -89,6 +89,11 @@ public class DHGroups {
         public String getName() {
             return name;
         }
+
+        @Override
+        public String toString() {
+            return name;
+        }
     }
 
 }

src/main/java/com/hierynomus/sshj/transport/verification/KnownHostMatchers.java

@@ -15,13 +15,13 @@
  */
 package com.hierynomus.sshj.transport.verification;
 
-import net.schmizz.sshj.common.Base64;
 import net.schmizz.sshj.common.IOUtils;
 import net.schmizz.sshj.common.SSHException;
 import net.schmizz.sshj.transport.mac.MAC;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Base64;
 import java.util.List;
 import java.util.regex.Pattern;
 
@@ -85,12 +85,12 @@ public class KnownHostMatchers {
 
         private String hashHost(String host) throws IOException {
             sha1.init(getSaltyBytes());
-            return "|1|" + salt + "|" + Base64.encodeBytes(sha1.doFinal(host.getBytes(IOUtils.UTF8)));
+            return "|1|" + salt + "|" + Base64.getEncoder().encodeToString(sha1.doFinal(host.getBytes(IOUtils.UTF8)));
         }
 
-        private byte[] getSaltyBytes() throws IOException {
+        private byte[] getSaltyBytes() {
             if (saltyBytes == null) {
-                saltyBytes = Base64.decode(salt);
+                saltyBytes = Base64.getDecoder().decode(salt);
             }
             return saltyBytes;
         }

src/main/java/com/hierynomus/sshj/userauth/keyprovider/OpenSSHKeyFileUtil.java

@@ -15,7 +15,6 @@
  */
 package com.hierynomus.sshj.userauth.keyprovider;
 
-import net.schmizz.sshj.common.Base64;
 import net.schmizz.sshj.common.Buffer;
 import net.schmizz.sshj.common.KeyType;
 
@@ -24,6 +23,7 @@ import java.io.File;
 import java.io.IOException;
 import java.io.Reader;
 import java.security.PublicKey;
+import java.util.Base64;
 
 public class OpenSSHKeyFileUtil {
     private OpenSSHKeyFileUtil() {
@@ -56,7 +56,7 @@ public class OpenSSHKeyFileUtil {
                     if (parts.length >= 2) {
                         return new ParsedPubKey(
                                 KeyType.fromString(parts[0]),
-                                new Buffer.PlainBuffer(Base64.decode(parts[1])).readPublicKey()
+                                new Buffer.PlainBuffer(Base64.getDecoder().decode(parts[1])).readPublicKey()
                         );
                     } else {
                         throw new IOException("Got line with only one column");

src/main/java/com/hierynomus/sshj/userauth/keyprovider/OpenSSHKeyV1KeyFile.java

@@ -18,11 +18,18 @@ package com.hierynomus.sshj.userauth.keyprovider;
 import com.hierynomus.sshj.common.KeyAlgorithm;
 import com.hierynomus.sshj.common.KeyDecryptionFailedException;
 import com.hierynomus.sshj.transport.cipher.BlockCiphers;
+import com.hierynomus.sshj.transport.cipher.ChachaPolyCiphers;
+import com.hierynomus.sshj.transport.cipher.GcmCiphers;
 import net.i2p.crypto.eddsa.EdDSAPrivateKey;
 import net.i2p.crypto.eddsa.spec.EdDSANamedCurveTable;
 import net.i2p.crypto.eddsa.spec.EdDSAPrivateKeySpec;
-import net.schmizz.sshj.common.*;
+import net.schmizz.sshj.common.Buffer;
 import net.schmizz.sshj.common.Buffer.PlainBuffer;
+import net.schmizz.sshj.common.ByteArrayUtils;
+import net.schmizz.sshj.common.IOUtils;
+import net.schmizz.sshj.common.KeyType;
+import net.schmizz.sshj.common.SSHRuntimeException;
+import net.schmizz.sshj.common.SecurityUtils;
 import net.schmizz.sshj.transport.cipher.Cipher;
 import net.schmizz.sshj.userauth.keyprovider.BaseFileKeyProvider;
 import net.schmizz.sshj.userauth.keyprovider.FileKeyProvider;
@@ -31,6 +38,7 @@ import org.bouncycastle.asn1.nist.NISTNamedCurves;
 import org.bouncycastle.asn1.x9.X9ECParameters;
 import org.bouncycastle.jce.spec.ECNamedCurveSpec;
 import com.hierynomus.sshj.userauth.keyprovider.bcrypt.BCrypt;
+import org.bouncycastle.openssl.EncryptionException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -42,23 +50,43 @@ import java.io.Reader;
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
-import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.security.*;
 import java.security.spec.ECPrivateKeySpec;
 import java.security.spec.RSAPrivateCrtKeySpec;
 import java.util.Arrays;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
 
 /**
  * Reads a key file in the new OpenSSH format.
  * The format is described in the following document: https://github.com/openssh/openssh-portable/blob/master/PROTOCOL.key
  */
 public class OpenSSHKeyV1KeyFile extends BaseFileKeyProvider {
-    private static final Logger logger = LoggerFactory.getLogger(OpenSSHKeyV1KeyFile.class);
     private static final String BEGIN = "-----BEGIN ";
     private static final String END = "-----END ";
     private static final byte[] AUTH_MAGIC = "openssh-key-v1\0".getBytes();
     public static final String OPENSSH_PRIVATE_KEY = "OPENSSH PRIVATE KEY-----";
     public static final String BCRYPT = "bcrypt";
+
+    private static final String NONE_CIPHER = "none";
+
+    private static final Map<String, Factory.Named<Cipher>> SUPPORTED_CIPHERS = new HashMap<>();
+
+    static {
+        SUPPORTED_CIPHERS.put(BlockCiphers.TripleDESCBC().getName(), BlockCiphers.TripleDESCBC());
+        SUPPORTED_CIPHERS.put(BlockCiphers.AES128CBC().getName(), BlockCiphers.AES128CBC());
+        SUPPORTED_CIPHERS.put(BlockCiphers.AES192CBC().getName(), BlockCiphers.AES192CBC());
+        SUPPORTED_CIPHERS.put(BlockCiphers.AES256CBC().getName(), BlockCiphers.AES256CBC());
+        SUPPORTED_CIPHERS.put(BlockCiphers.AES128CTR().getName(), BlockCiphers.AES128CTR());
+        SUPPORTED_CIPHERS.put(BlockCiphers.AES192CTR().getName(), BlockCiphers.AES192CTR());
+        SUPPORTED_CIPHERS.put(BlockCiphers.AES256CTR().getName(), BlockCiphers.AES256CTR());
+        SUPPORTED_CIPHERS.put(GcmCiphers.AES256GCM().getName(), GcmCiphers.AES256GCM());
+        SUPPORTED_CIPHERS.put(GcmCiphers.AES128GCM().getName(), GcmCiphers.AES128GCM());
+        SUPPORTED_CIPHERS.put(ChachaPolyCiphers.CHACHA_POLY_OPENSSH().getName(), ChachaPolyCiphers.CHACHA_POLY_OPENSSH());
+    }
+
     private PublicKey pubKey;
 
     public static class Factory
@@ -92,19 +120,19 @@ public class OpenSSHKeyV1KeyFile extends BaseFileKeyProvider {
 
     @Override
     protected KeyPair readKeyPair() throws IOException {
-        BufferedReader reader = new BufferedReader(resource.getReader());
+        final BufferedReader reader = new BufferedReader(resource.getReader());
         try {
-            if (!checkHeader(reader)) {
-                throw new IOException("This key is not in 'openssh-key-v1' format");
+            if (checkHeader(reader)) {
+                final String encodedPrivateKey = readEncodedKey(reader);
+                byte[] decodedPrivateKey = Base64.getDecoder().decode(encodedPrivateKey);
+                final PlainBuffer bufferedPrivateKey = new PlainBuffer(decodedPrivateKey);
+                return readDecodedKeyPair(bufferedPrivateKey);
+            } else {
+                final String message = String.format("File header not found [%s%s]", BEGIN, OPENSSH_PRIVATE_KEY);
+                throw new IOException(message);
             }
-
-            String keyFile = readKeyFile(reader);
-            byte[] decode = Base64.decode(keyFile);
-            PlainBuffer keyBuffer = new PlainBuffer(decode);
-            return readDecodedKeyPair(keyBuffer);
-
-        } catch (GeneralSecurityException e) {
-            throw new SSHRuntimeException(e);
+        } catch (final GeneralSecurityException e) {
+            throw new SSHRuntimeException("Read OpenSSH Version 1 Key failed", e);
         } finally {
             IOUtils.closeQuietly(reader);
         }
@@ -129,86 +157,143 @@ public class OpenSSHKeyV1KeyFile extends BaseFileKeyProvider {
 
         int nrKeys = keyBuffer.readUInt32AsInt(); // int number of keys N; Should be 1
         if (nrKeys != 1) {
-            throw new IOException("We don't support having more than 1 key in the file (yet).");
+            final String message = String.format("OpenSSH Private Key number of keys not supported [%d]", nrKeys);
+            throw new IOException(message);
         }
         PublicKey publicKey = pubKey;
         if (publicKey == null) {
             publicKey = readPublicKey(new PlainBuffer(keyBuffer.readBytes()));
-        }
-        else {
+        } else {
             keyBuffer.readBytes();
         }
-        PlainBuffer privateKeyBuffer = new PlainBuffer(keyBuffer.readBytes()); // string (possibly) encrypted, padded list of private keys
-        if ("none".equals(cipherName)) {
-            logger.debug("Reading unencrypted keypair");
+
+        final byte[] privateKeyEncoded = keyBuffer.readBytes();
+        final PlainBuffer privateKeyBuffer = new PlainBuffer(privateKeyEncoded);
+
+        if (NONE_CIPHER.equals(cipherName)) {
             return readUnencrypted(privateKeyBuffer, publicKey);
         } else {
-            logger.info("Keypair is encrypted with: " + cipherName + ", " + kdfName + ", " + Arrays.toString(kdfOptions));
+            final byte[] encryptedPrivateKey = readEncryptedPrivateKey(privateKeyEncoded, keyBuffer);
             while (true) {
-                PlainBuffer decryptionBuffer = new PlainBuffer(privateKeyBuffer);
-                PlainBuffer decrypted = decryptBuffer(decryptionBuffer, cipherName, kdfName, kdfOptions);
+                final byte[] encrypted = encryptedPrivateKey.clone();
                 try {
+                    final PlainBuffer decrypted = decryptPrivateKey(encrypted, privateKeyEncoded.length, cipherName, kdfName, kdfOptions);
                     return readUnencrypted(decrypted, publicKey);
                 } catch (KeyDecryptionFailedException e) {
                     if (pwdf == null || !pwdf.shouldRetry(resource))
                         throw e;
                 }
             }
-//            throw new IOException("Cannot read encrypted keypair with " + cipherName + " yet.");
         }
     }
 
-    private PlainBuffer decryptBuffer(PlainBuffer privateKeyBuffer, String cipherName, String kdfName, byte[] kdfOptions) throws IOException {
-        Cipher cipher = createCipher(cipherName);
-        initializeCipher(kdfName, kdfOptions, cipher);
-        byte[] array = privateKeyBuffer.array();
-        cipher.update(array, 0, privateKeyBuffer.available());
-        return new PlainBuffer(array);
+    private byte[] readEncryptedPrivateKey(final byte[] privateKeyEncoded, final PlainBuffer inputBuffer) throws Buffer.BufferException {
+        final byte[] encryptedPrivateKey;
+
+        final int bufferRemaining = inputBuffer.available();
+        if (bufferRemaining == 0) {
+            encryptedPrivateKey = privateKeyEncoded;
+        } else {
+            // Read Authentication Tag for AES-GCM or ChaCha20-Poly1305
+            final byte[] authenticationTag = new byte[bufferRemaining];
+            inputBuffer.readRawBytes(authenticationTag);
+
+            final int encryptedBufferLength = privateKeyEncoded.length + authenticationTag.length;
+            final PlainBuffer encryptedBuffer = new PlainBuffer(encryptedBufferLength);
+            encryptedBuffer.putRawBytes(privateKeyEncoded);
+            encryptedBuffer.putRawBytes(authenticationTag);
+
+            encryptedPrivateKey = new byte[encryptedBufferLength];
+            encryptedBuffer.readRawBytes(encryptedPrivateKey);
+        }
+
+        return encryptedPrivateKey;
     }
 
-    private void initializeCipher(String kdfName, byte[] kdfOptions, Cipher cipher) throws Buffer.BufferException {
+    private PlainBuffer decryptPrivateKey(final byte[] privateKey, final int privateKeyLength, final String cipherName, final String kdfName, final byte[] kdfOptions) throws IOException {
+        try {
+            final Cipher cipher = createCipher(cipherName);
+            initializeCipher(kdfName, kdfOptions, cipher);
+            cipher.update(privateKey, 0, privateKeyLength);
+        } catch (final SSHRuntimeException e) {
+            final String message = String.format("OpenSSH Private Key decryption failed with cipher [%s]", cipherName);
+            throw new KeyDecryptionFailedException(new EncryptionException(message, e));
+        }
+        final PlainBuffer decryptedPrivateKey = new PlainBuffer(privateKeyLength);
+        decryptedPrivateKey.putRawBytes(privateKey, 0, privateKeyLength);
+        return decryptedPrivateKey;
+    }
+
+    private void initializeCipher(final String kdfName, final byte[] kdfOptions, final Cipher cipher) throws Buffer.BufferException {
         if (kdfName.equals(BCRYPT)) {
-            PlainBuffer opts = new PlainBuffer(kdfOptions);
+            final PlainBuffer bufferedOptions = new PlainBuffer(kdfOptions);
             byte[] passphrase = new byte[0];
             if (pwdf != null) {
-                CharBuffer charBuffer = CharBuffer.wrap(pwdf.reqPassword(null));
-                ByteBuffer byteBuffer = Charset.forName("UTF-8").encode(charBuffer);
+                final CharBuffer charBuffer = CharBuffer.wrap(pwdf.reqPassword(null));
+                final ByteBuffer byteBuffer = StandardCharsets.UTF_8.encode(charBuffer);
                 passphrase = Arrays.copyOfRange(byteBuffer.array(), byteBuffer.position(), byteBuffer.limit());
                 Arrays.fill(charBuffer.array(), '\u0000');
                 Arrays.fill(byteBuffer.array(), (byte) 0);
             }
-            byte[] keyiv = new byte[48];
-            new BCrypt().pbkdf(passphrase, opts.readBytes(), opts.readUInt32AsInt(), keyiv);
+
+            final int ivSize = cipher.getIVSize();
+            final int blockSize = cipher.getBlockSize();
+            final int parameterSize = ivSize + blockSize;
+            final byte[] keyIvParameters = new byte[parameterSize];
+
+            final byte[] salt = bufferedOptions.readBytes();
+            final int iterations = bufferedOptions.readUInt32AsInt();
+            new BCrypt().pbkdf(passphrase, salt, iterations, keyIvParameters);
             Arrays.fill(passphrase, (byte) 0);
-            byte[] key = Arrays.copyOfRange(keyiv, 0, 32);
-            byte[] iv = Arrays.copyOfRange(keyiv, 32, 48);
+
+            final byte[] key = Arrays.copyOfRange(keyIvParameters, 0, blockSize);
+            final byte[] iv = Arrays.copyOfRange(keyIvParameters, blockSize, parameterSize);
+
             cipher.init(Cipher.Mode.Decrypt, key, iv);
         } else {
-            throw new IllegalStateException("No support for KDF '" + kdfName + "'.");
+            final String message = String.format("OpenSSH Private Key encryption KDF not supported [%s]", kdfName);
+            throw new IllegalStateException(message);
         }
     }
 
-    private Cipher createCipher(String cipherName) {
-        if (cipherName.equals(BlockCiphers.AES256CTR().getName())) {
-            return BlockCiphers.AES256CTR().create();
-        } else if (cipherName.equals(BlockCiphers.AES256CBC().getName())) {
-            return BlockCiphers.AES256CBC().create();
+    private Cipher createCipher(final String cipherName) {
+        final Cipher cipher;
+
+        if (SUPPORTED_CIPHERS.containsKey(cipherName)) {
+            final Factory.Named<Cipher> cipherFactory = SUPPORTED_CIPHERS.get(cipherName);
+            cipher = cipherFactory.create();
+        } else {
+            final String message = String.format("OpenSSH Key encryption cipher not supported [%s]", cipherName);
+            throw new IllegalStateException(message);
         }
-        throw new IllegalStateException("Cipher '" + cipherName + "' not currently implemented for openssh-key-v1 format");
+
+        return cipher;
     }
 
     private PublicKey readPublicKey(final PlainBuffer plainBuffer) throws Buffer.BufferException, GeneralSecurityException {
         return KeyType.fromString(plainBuffer.readString()).readPubKeyFromBuffer(plainBuffer);
     }
 
-    private String readKeyFile(final BufferedReader reader) throws IOException {
-        StringBuilder sb = new StringBuilder();
+    private String readEncodedKey(final BufferedReader reader) throws IOException {
+        final StringBuilder builder = new StringBuilder();
+
+        boolean footerFound = false;
         String line = reader.readLine();
-        while (!line.startsWith(END)) {
-            sb.append(line);
+        while (line != null) {
+            if (line.startsWith(END)) {
+                footerFound = true;
+                break;
+            }
+            builder.append(line);
             line = reader.readLine();
         }
-        return sb.toString();
+
+        if (footerFound) {
+            return builder.toString();
+        } else {
+            final String message = String.format("File footer not found [%s%s]", END, OPENSSH_PRIVATE_KEY);
+            throw new IOException(message);
+        }
     }
 
     private boolean checkHeader(final BufferedReader reader) throws IOException {
@@ -216,6 +301,9 @@ public class OpenSSHKeyV1KeyFile extends BaseFileKeyProvider {
         while (line != null && !line.startsWith(BEGIN)) {
             line = reader.readLine();
         }
+        if (line == null) {
+            return false;
+        }
         line = line.substring(BEGIN.length());
         return line.startsWith(OPENSSH_PRIVATE_KEY);
     }
@@ -228,12 +316,12 @@ public class OpenSSHKeyV1KeyFile extends BaseFileKeyProvider {
         int checkInt1 = keyBuffer.readUInt32AsInt(); // uint32 checkint1
         int checkInt2 = keyBuffer.readUInt32AsInt(); // uint32 checkint2
         if (checkInt1 != checkInt2) {
-            throw new KeyDecryptionFailedException();
+            throw new KeyDecryptionFailedException(new EncryptionException("OpenSSH Private Key integer comparison failed"));
         }
         // The private key section contains both the public key and the private key
         String keyType = keyBuffer.readString(); // string keytype
         KeyType kt = KeyType.fromString(keyType);
-        logger.info("Read key type: {}", keyType, kt);
+
         KeyPair kp;
         switch (kt) {
             case ED25519:

src/main/java/com/hierynomus/sshj/userauth/keyprovider/bcrypt/BCrypt.java

@@ -14,11 +14,9 @@
 
 package com.hierynomus.sshj.userauth.keyprovider.bcrypt;
 
-import java.io.UnsupportedEncodingException;
 import java.security.DigestException;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
-import java.security.SecureRandom;
 
 /**
  * BCrypt implements OpenBSD-style Blowfish password hashing using
@@ -30,32 +28,6 @@ import java.security.SecureRandom;
  * based on Bruce Schneier's Blowfish cipher. The work factor of
  * the algorithm is parameterised, so it can be increased as
  * computers get faster.
- * <p>
- * Usage is really simple. To hash a password for the first time,
- * call the hashpw method with a random salt, like this:
- * <p>
- * <code>
- * String pw_hash = BCrypt.hashpw(plain_password, BCrypt.gensalt()); <br>
- * </code>
- * <p>
- * To check whether a plaintext password matches one that has been
- * hashed previously, use the checkpw method:
- * <p>
- * <code>
- * if (BCrypt.checkpw(candidate_password, stored_hash))<br>
- * &nbsp;&nbsp;&nbsp;&nbsp;System.out.println("It matches");<br>
- * else<br>
- * &nbsp;&nbsp;&nbsp;&nbsp;System.out.println("It does not match");<br>
- * </code>
- * <p>
- * The gensalt() method takes an optional parameter (log_rounds)
- * that determines the computational complexity of the hashing:
- * <p>
- * <code>
- * String strong_salt = BCrypt.gensalt(10)<br>
- * String stronger_salt = BCrypt.gensalt(12)<br>
- * </code>
- * <p>
  * The amount of work increases exponentially (2**log_rounds), so
  * each increment is twice as much work. The default log_rounds is
  * 10, and the valid range is 4 to 30.
@@ -64,22 +36,18 @@ import java.security.SecureRandom;
  * @version 0.2
  */
 public class BCrypt {
-    // BCrypt parameters
-    private static final int GENSALT_DEFAULT_LOG2_ROUNDS = 10;
-    private static final int BCRYPT_SALT_LEN = 16;
-
     // Blowfish parameters
     private static final int BLOWFISH_NUM_ROUNDS = 16;
 
     // Initial contents of key schedule
-    private static final int P_orig[] = {
+    private static final int[] P_orig = {
             0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
             0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
             0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
             0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
             0x9216d5d9, 0x8979fb1b
     };
-    private static final int S_orig[] = {
+    private static final int[] S_orig = {
             0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
             0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
             0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
@@ -344,149 +312,9 @@ public class BCrypt {
             0x66697368, 0x53776174, 0x44796e61, 0x6d697465,
     };
 
-    // bcrypt IV: "OrpheanBeholderScryDoubt". The C implementation calls
-    // this "ciphertext", but it is really plaintext or an IV. We keep
-    // the name to make code comparison easier.
-    static private final int bf_crypt_ciphertext[] = {
-            0x4f727068, 0x65616e42, 0x65686f6c,
-            0x64657253, 0x63727944, 0x6f756274
-    };
-
-    // Table for Base64 encoding
-    static private final char base64_code[] = {
-            '.', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
-            'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
-            'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
-            'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
-            'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5',
-            '6', '7', '8', '9'
-    };
-
-    // Table for Base64 decoding
-    static private final byte index_64[] = {
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, 0, 1, 54, 55,
-            56, 57, 58, 59, 60, 61, 62, 63, -1, -1,
-            -1, -1, -1, -1, -1, 2, 3, 4, 5, 6,
-            7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-            17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
-            -1, -1, -1, -1, -1, -1, 28, 29, 30,
-            31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-            41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
-            51, 52, 53, -1, -1, -1, -1, -1
-    };
-
     // Expanded Blowfish key
-    private int P[];
-    private int S[];
-
-    /**
-     * Encode a byte array using bcrypt's slightly-modified base64
-     * encoding scheme. Note that this is *not* compatible with
-     * the standard MIME-base64 encoding.
-     *
-     * @param d	the byte array to encode
-     * @param len	the number of bytes to encode
-     * @return	base64-encoded string
-     * @exception IllegalArgumentException if the length is invalid
-     */
-    private static String encode_base64(byte d[], int len)
-            throws IllegalArgumentException {
-        int off = 0;
-        StringBuffer rs = new StringBuffer();
-        int c1, c2;
-
-        if (len <= 0 || len > d.length)
-            throw new IllegalArgumentException ("Invalid len");
-
-        while (off < len) {
-            c1 = d[off++] & 0xff;
-            rs.append(base64_code[(c1 >> 2) & 0x3f]);
-            c1 = (c1 & 0x03) << 4;
-            if (off >= len) {
-                rs.append(base64_code[c1 & 0x3f]);
-                break;
-            }
-            c2 = d[off++] & 0xff;
-            c1 |= (c2 >> 4) & 0x0f;
-            rs.append(base64_code[c1 & 0x3f]);
-            c1 = (c2 & 0x0f) << 2;
-            if (off >= len) {
-                rs.append(base64_code[c1 & 0x3f]);
-                break;
-            }
-            c2 = d[off++] & 0xff;
-            c1 |= (c2 >> 6) & 0x03;
-            rs.append(base64_code[c1 & 0x3f]);
-            rs.append(base64_code[c2 & 0x3f]);
-        }
-        return rs.toString();
-    }
-
-    /**
-     * Look up the 3 bits base64-encoded by the specified character,
-     * range-checking againt conversion table
-     * @param x	the base64-encoded value
-     * @return	the decoded value of x
-     */
-    private static byte char64(char x) {
-        if ((int)x < 0 || (int)x > index_64.length)
-            return -1;
-        return index_64[(int)x];
-    }
-
-    /**
-     * Decode a string encoded using bcrypt's base64 scheme to a
-     * byte array. Note that this is *not* compatible with
-     * the standard MIME-base64 encoding.
-     * @param s	the string to decode
-     * @param maxolen	the maximum number of bytes to decode
-     * @return	an array containing the decoded bytes
-     * @throws IllegalArgumentException if maxolen is invalid
-     */
-    private static byte[] decode_base64(String s, int maxolen)
-            throws IllegalArgumentException {
-        StringBuffer rs = new StringBuffer();
-        int off = 0, slen = s.length(), olen = 0;
-        byte ret[];
-        byte c1, c2, c3, c4, o;
-
-        if (maxolen <= 0)
-            throw new IllegalArgumentException ("Invalid maxolen");
-
-        while (off < slen - 1 && olen < maxolen) {
-            c1 = char64(s.charAt(off++));
-            c2 = char64(s.charAt(off++));
-            if (c1 == -1 || c2 == -1)
-                break;
-            o = (byte)(c1 << 2);
-            o |= (c2 & 0x30) >> 4;
-            rs.append((char)o);
-            if (++olen >= maxolen || off >= slen)
-                break;
-            c3 = char64(s.charAt(off++));
-            if (c3 == -1)
-                break;
-            o = (byte)((c2 & 0x0f) << 4);
-            o |= (c3 & 0x3c) >> 2;
-            rs.append((char)o);
-            if (++olen >= maxolen || off >= slen)
-                break;
-            c4 = char64(s.charAt(off++));
-            o = (byte)((c3 & 0x03) << 6);
-            o |= c4;
-            rs.append((char)o);
-            ++olen;
-        }
-
-        ret = new byte[olen];
-        for (off = 0; off < olen; off++)
-            ret[off] = (byte)rs.charAt(off);
-        return ret;
-    }
+    private int[] P;
+    private int[] S;
 
     /**
      * Blowfish encipher a single 64-bit block encoded as
@@ -494,7 +322,7 @@ public class BCrypt {
      * @param lr	an array containing the two 32-bit half blocks
      * @param off	the position in the array of the blocks
      */
-    private final void encipher(int lr[], int off) {
+    private void encipher(int[] lr, int off) {
         int i, n, l = lr[off], r = lr[off + 1];
 
         l ^= P[0];
@@ -524,7 +352,7 @@ public class BCrypt {
      * current offset into data
      * @return	the next word of material from data
      */
-    private static int streamtoword(byte data[], int offp[]) {
+    private static int streamtoword(byte[] data, int[] offp) {
         int i;
         int word = 0;
         int off = offp[0];
@@ -542,18 +370,18 @@ public class BCrypt {
      * Initialise the Blowfish key schedule
      */
     private void init_key() {
-        P = (int[])P_orig.clone();
-        S = (int[])S_orig.clone();
+        P = P_orig.clone();
+        S = S_orig.clone();
     }
 
     /**
      * Key the Blowfish cipher
      * @param key	an array containing the key
      */
-    private void key(byte key[]) {
+    private void key(byte[] key) {
         int i;
-        int koffp[] = { 0 };
-        int lr[] = { 0, 0 };
+        int[] koffp = { 0 };
+        int[] lr = { 0, 0 };
         int plen = P.length, slen = S.length;
 
         for (i = 0; i < plen; i++)
@@ -579,10 +407,10 @@ public class BCrypt {
      * @param data	salt information
      * @param key	password information
      */
-    private void ekskey(byte data[], byte key[]) {
+    private void ekskey(byte[] data, byte[] key) {
         int i;
-        int koffp[] = { 0 }, doffp[] = { 0 };
-        int lr[] = { 0, 0 };
+        int[] koffp = { 0 }, doffp = { 0 };
+        int[] lr = { 0, 0 };
         int plen = P.length, slen = S.length;
 
         for (i = 0; i < plen; i++)
@@ -687,183 +515,4 @@ public class BCrypt {
             throw new RuntimeException(e);
         }
     }
-
-    /**
-     * Perform the central password hashing step in the
-     * bcrypt scheme
-     * @param password	the password to hash
-     * @param salt	the binary salt to hash with the password
-     * @param log_rounds	the binary logarithm of the number
-     * of rounds of hashing to apply
-     * @param cdata         the plaintext to encrypt
-     * @return	an array containing the binary hashed password
-     */
-    public byte[] crypt_raw(byte password[], byte salt[], int log_rounds,
-                            int cdata[]) {
-        int rounds, i, j;
-        int clen = cdata.length;
-        byte ret[];
-
-        if (log_rounds < 4 || log_rounds > 30)
-            throw new IllegalArgumentException ("Bad number of rounds");
-        rounds = 1 << log_rounds;
-        if (salt.length != BCRYPT_SALT_LEN)
-            throw new IllegalArgumentException ("Bad salt length");
-
-        init_key();
-        ekskey(salt, password);
-        for (i = 0; i != rounds; i++) {
-            key(password);
-            key(salt);
-        }
-
-        for (i = 0; i < 64; i++) {
-            for (j = 0; j < (clen >> 1); j++)
-                encipher(cdata, j << 1);
-        }
-
-        ret = new byte[clen * 4];
-        for (i = 0, j = 0; i < clen; i++) {
-            ret[j++] = (byte)((cdata[i] >> 24) & 0xff);
-            ret[j++] = (byte)((cdata[i] >> 16) & 0xff);
-            ret[j++] = (byte)((cdata[i] >> 8) & 0xff);
-            ret[j++] = (byte)(cdata[i] & 0xff);
-        }
-        return ret;
-    }
-
-    /**
-     * Hash a password using the OpenBSD bcrypt scheme
-     * @param password	the password to hash
-     * @param salt	the salt to hash with (perhaps generated
-     * using BCrypt.gensalt)
-     * @return	the hashed password
-     */
-    public static String hashpw(String password, String salt) {
-        BCrypt B;
-        String real_salt;
-        byte passwordb[], saltb[], hashed[];
-        char minor = (char)0;
-        int rounds, off = 0;
-        StringBuffer rs = new StringBuffer();
-
-        if (salt.charAt(0) != '$' || salt.charAt(1) != '2')
-            throw new IllegalArgumentException ("Invalid salt version");
-        if (salt.charAt(2) == '$')
-            off = 3;
-        else {
-            minor = salt.charAt(2);
-            if (minor != 'a' || salt.charAt(3) != '$')
-                throw new IllegalArgumentException ("Invalid salt revision");
-            off = 4;
-        }
-
-        // Extract number of rounds
-        if (salt.charAt(off + 2) > '$')
-            throw new IllegalArgumentException ("Missing salt rounds");
-        rounds = Integer.parseInt(salt.substring(off, off + 2));
-
-        real_salt = salt.substring(off + 3, off + 25);
-        try {
-            passwordb = (password + (minor >= 'a' ? "\000" : "")).getBytes("UTF-8");
-        } catch (UnsupportedEncodingException uee) {
-            throw new AssertionError("UTF-8 is not supported");
-        }
-
-        saltb = decode_base64(real_salt, BCRYPT_SALT_LEN);
-
-        B = new BCrypt();
-        hashed = B.crypt_raw(passwordb, saltb, rounds,
-                (int[])bf_crypt_ciphertext.clone());
-
-        rs.append("$2");
-        if (minor >= 'a')
-            rs.append(minor);
-        rs.append("$");
-        if (rounds < 10)
-            rs.append("0");
-        if (rounds > 30) {
-            throw new IllegalArgumentException(
-                    "rounds exceeds maximum (30)");
-        }
-        rs.append(Integer.toString(rounds));
-        rs.append("$");
-        rs.append(encode_base64(saltb, saltb.length));
-        rs.append(encode_base64(hashed,
-                bf_crypt_ciphertext.length * 4 - 1));
-        return rs.toString();
-    }
-
-    /**
-     * Generate a salt for use with the BCrypt.hashpw() method
-     * @param log_rounds	the log2 of the number of rounds of
-     * hashing to apply - the work factor therefore increases as
-     * 2**log_rounds.
-     * @param random		an instance of SecureRandom to use
-     * @return	an encoded salt value
-     */
-    public static String gensalt(int log_rounds, SecureRandom random) {
-        StringBuffer rs = new StringBuffer();
-        byte rnd[] = new byte[BCRYPT_SALT_LEN];
-
-        random.nextBytes(rnd);
-
-        rs.append("$2a$");
-        if (log_rounds < 10)
-            rs.append("0");
-        if (log_rounds > 30) {
-            throw new IllegalArgumentException(
-                    "log_rounds exceeds maximum (30)");
-        }
-        rs.append(Integer.toString(log_rounds));
-        rs.append("$");
-        rs.append(encode_base64(rnd, rnd.length));
-        return rs.toString();
-    }
-
-    /**
-     * Generate a salt for use with the BCrypt.hashpw() method
-     * @param log_rounds	the log2 of the number of rounds of
-     * hashing to apply - the work factor therefore increases as
-     * 2**log_rounds.
-     * @return	an encoded salt value
-     */
-    public static String gensalt(int log_rounds) {
-        return gensalt(log_rounds, new SecureRandom());
-    }
-
-    /**
-     * Generate a salt for use with the BCrypt.hashpw() method,
-     * selecting a reasonable default for the number of hashing
-     * rounds to apply
-     * @return	an encoded salt value
-     */
-    public static String gensalt() {
-        return gensalt(GENSALT_DEFAULT_LOG2_ROUNDS);
-    }
-
-    /**
-     * Check that a plaintext password matches a previously hashed
-     * one
-     * @param plaintext	the plaintext password to verify
-     * @param hashed	the previously-hashed password
-     * @return	true if the passwords match, false otherwise
-     */
-    public static boolean checkpw(String plaintext, String hashed) {
-        byte hashed_bytes[];
-        byte try_bytes[];
-        try {
-            String try_pw = hashpw(plaintext, hashed);
-            hashed_bytes = hashed.getBytes("UTF-8");
-            try_bytes = try_pw.getBytes("UTF-8");
-        } catch (UnsupportedEncodingException uee) {
-            return false;
-        }
-        if (hashed_bytes.length != try_bytes.length)
-            return false;
-        byte ret = 0;
-        for (int i = 0; i < try_bytes.length; i++)
-            ret |= hashed_bytes[i] ^ try_bytes[i];
-        return ret == 0;
-    }
 }

src/main/java/djb/Curve25519.java

@@ -1,918 +0,0 @@
-/* Ported from C to Java by Dmitry Skiba [sahn0], 23/02/08.
- * Original: http://cds.xs4all.nl:8081/ecdh/
- */
-/* Generic 64-bit integer implementation of Curve25519 ECDH
- * Written by Matthijs van Duin, 200608242056
- * Public domain.
- *
- * Based on work by Daniel J Bernstein, http://cr.yp.to/ecdh.html
- */
-package djb;
-
-public class Curve25519 {
-
-	/* key size */
-	public static final int KEY_SIZE = 32;
-	
-	/* 0 */
-	public static final byte[] ZERO = {
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-	};
-	
-	/* the prime 2^255-19 */
-	public static final byte[] PRIME = {
-		(byte)237, (byte)255, (byte)255, (byte)255,
-		(byte)255, (byte)255, (byte)255, (byte)255,
-		(byte)255, (byte)255, (byte)255, (byte)255,
-		(byte)255, (byte)255, (byte)255, (byte)255,
-		(byte)255, (byte)255, (byte)255, (byte)255,
-		(byte)255, (byte)255, (byte)255, (byte)255,
-	    (byte)255, (byte)255, (byte)255, (byte)255,
-	    (byte)255, (byte)255, (byte)255, (byte)127
-	};
-	
-	/* group order (a prime near 2^252+2^124) */
-	public static final byte[] ORDER = {
-		(byte)237, (byte)211, (byte)245, (byte)92,
-		(byte)26,  (byte)99,  (byte)18,  (byte)88,
-		(byte)214, (byte)156, (byte)247, (byte)162,
-		(byte)222, (byte)249, (byte)222, (byte)20,
-		(byte)0,   (byte)0,   (byte)0,   (byte)0, 
-		(byte)0,   (byte)0,   (byte)0,   (byte)0,
-		(byte)0,   (byte)0,   (byte)0,   (byte)0, 
-		(byte)0,   (byte)0,   (byte)0,   (byte)16
-	};
-	
-	/********* KEY AGREEMENT *********/
-	
-	/* Private key clamping
-	 *   k [out] your private key for key agreement
-	 *   k  [in]  32 random bytes
-	 */
-	public static final void clamp(byte[] k) {
-		k[31] &= 0x7F;
-		k[31] |= 0x40;
-		k[ 0] &= 0xF8;
-	}
-	
-	/* Key-pair generation
-	 *   P  [out] your public key
-	 *   s  [out] your private key for signing
-	 *   k  [out] your private key for key agreement
-	 *   k  [in]  32 random bytes
-	 * s may be NULL if you don't care
-	 *
-	 * WARNING: if s is not NULL, this function has data-dependent timing */
-	public static final void keygen(byte[] P, byte[] s, byte[] k) {
-		clamp(k);
-		core(P, s, k, null);
-	}
-
-	/* Key agreement
-	 *   Z  [out] shared secret (needs hashing before use)
-	 *   k  [in]  your private key for key agreement
-	 *   P  [in]  peer's public key
-	 */
-	public static final void curve(byte[] Z, byte[] k, byte[] P) {
-		core(Z, null, k, P);
-	}
-	
-	/********* DIGITAL SIGNATURES *********/
-
-	/* deterministic EC-KCDSA
-	 *
-	 *    s is the private key for signing
-	 *    P is the corresponding public key
-	 *    Z is the context data (signer public key or certificate, etc)
-	 *
-	 * signing:
-	 *
-	 *    m = hash(Z, message)
-	 *    x = hash(m, s)
-	 *    keygen25519(Y, NULL, x);
-	 *    r = hash(Y);
-	 *    h = m XOR r
-	 *    sign25519(v, h, x, s);
-	 *
-	 *    output (v,r) as the signature
-	 *
-	 * verification:
-	 *
-	 *    m = hash(Z, message);
-	 *    h = m XOR r
-	 *    verify25519(Y, v, h, P)
-	 *
-	 *    confirm  r == hash(Y)
-	 *
-	 * It would seem to me that it would be simpler to have the signer directly do 
-	 * h = hash(m, Y) and send that to the recipient instead of r, who can verify 
-	 * the signature by checking h == hash(m, Y).  If there are any problems with 
-	 * such a scheme, please let me know.
-	 *
-	 * Also, EC-KCDSA (like most DS algorithms) picks x random, which is a waste of 
-	 * perfectly good entropy, but does allow Y to be calculated in advance of (or 
-	 * parallel to) hashing the message.
-	 */
-	
-	/* Signature generation primitive, calculates (x-h)s mod q
-	 *   v  [out] signature value
-	 *   h  [in]  signature hash (of message, signature pub key, and context data)
-	 *   x  [in]  signature private key
-	 *   s  [in]  private key for signing
-	 * returns true on success, false on failure (use different x or h)
-	 */
-	public static final boolean sign(byte[] v, byte[] h, byte[] x, byte[] s) {
-		// v = (x - h) s  mod q
-		int w, i;
-		byte[] h1 = new byte[32], x1 = new byte[32];
-		byte[] tmp1 = new byte[64];
-		byte[] tmp2 = new byte[64];
-
-		// Don't clobber the arguments, be nice!
-		cpy32(h1, h);
-		cpy32(x1, x);
-
-		// Reduce modulo group order
-		byte[] tmp3=new byte[32];
-		divmod(tmp3, h1, 32, ORDER, 32);
-		divmod(tmp3, x1, 32, ORDER, 32);
-
-		// v = x1 - h1
-		// If v is negative, add the group order to it to become positive.
-		// If v was already positive we don't have to worry about overflow
-		// when adding the order because v < ORDER and 2*ORDER < 2^256
-		mula_small(v, x1, 0, h1, 32, -1);
-		mula_small(v, v , 0, ORDER, 32, 1);
-
-		// tmp1 = (x-h)*s mod q
-		mula32(tmp1, v, s, 32, 1);
-		divmod(tmp2, tmp1, 64, ORDER, 32);
-
-		for (w = 0, i = 0; i < 32; i++)
-			w |= v[i] = tmp1[i];
-		return w != 0;
-	}
-
-	/* Signature verification primitive, calculates Y = vP + hG
-	 *   Y  [out] signature public key
-	 *   v  [in]  signature value
-	 *   h  [in]  signature hash
-	 *   P  [in]  public key
-	 */
-	public static final void verify(byte[] Y, byte[] v, byte[] h, byte[] P) {
-		/* Y = v abs(P) + h G  */
-		byte[] d=new byte[32];
-	    long10[] 
-	        p=new long10[]{new long10(),new long10()},
-	    	s=new long10[]{new long10(),new long10()},
-		    yx=new long10[]{new long10(),new long10(),new long10()},
-		    yz=new long10[]{new long10(),new long10(),new long10()},
-		    t1=new long10[]{new long10(),new long10(),new long10()},
-		    t2=new long10[]{new long10(),new long10(),new long10()};
-		
-		int vi = 0, hi = 0, di = 0, nvh=0, i, j, k;
-
-		/* set p[0] to G and p[1] to P  */
-
-		set(p[0], 9);
-		unpack(p[1], P);
-
-		/* set s[0] to P+G and s[1] to P-G  */
-
-		/* s[0] = (Py^2 + Gy^2 - 2 Py Gy)/(Px - Gx)^2 - Px - Gx - 486662  */
-		/* s[1] = (Py^2 + Gy^2 + 2 Py Gy)/(Px - Gx)^2 - Px - Gx - 486662  */
-
-		x_to_y2(t1[0], t2[0], p[1]);	/* t2[0] = Py^2  */
-		sqrt(t1[0], t2[0]);	/* t1[0] = Py or -Py  */
-		j = is_negative(t1[0]);		/*      ... check which  */
-		t2[0]._0 += 39420360;		/* t2[0] = Py^2 + Gy^2  */
-		mul(t2[1], BASE_2Y, t1[0]);/* t2[1] = 2 Py Gy or -2 Py Gy  */
-		sub(t1[j], t2[0], t2[1]);	/* t1[0] = Py^2 + Gy^2 - 2 Py Gy  */
-		add(t1[1-j], t2[0], t2[1]);/* t1[1] = Py^2 + Gy^2 + 2 Py Gy  */
-		cpy(t2[0], p[1]);		/* t2[0] = Px  */
-		t2[0]._0 -= 9;			/* t2[0] = Px - Gx  */
-		sqr(t2[1], t2[0]);		/* t2[1] = (Px - Gx)^2  */
-		recip(t2[0], t2[1], 0);	/* t2[0] = 1/(Px - Gx)^2  */
-		mul(s[0], t1[0], t2[0]);	/* s[0] = t1[0]/(Px - Gx)^2  */
-		sub(s[0], s[0], p[1]);	/* s[0] = t1[0]/(Px - Gx)^2 - Px  */
-		s[0]._0 -= 9 + 486662;		/* s[0] = X(P+G)  */
-		mul(s[1], t1[1], t2[0]);	/* s[1] = t1[1]/(Px - Gx)^2  */
-		sub(s[1], s[1], p[1]);	/* s[1] = t1[1]/(Px - Gx)^2 - Px  */
-		s[1]._0 -= 9 + 486662;		/* s[1] = X(P-G)  */
-		mul_small(s[0], s[0], 1);	/* reduce s[0] */
-		mul_small(s[1], s[1], 1);	/* reduce s[1] */
-
-
-		/* prepare the chain  */
-		for (i = 0; i < 32; i++) {
-			vi = (vi >> 8) ^ (v[i] & 0xFF) ^ ((v[i] & 0xFF) << 1);
-			hi = (hi >> 8) ^ (h[i] & 0xFF) ^ ((h[i] & 0xFF) << 1);
-			nvh = ~(vi ^ hi);
-			di = (nvh & (di & 0x80) >> 7) ^ vi;
-			di ^= nvh & (di & 0x01) << 1;
-			di ^= nvh & (di & 0x02) << 1;
-			di ^= nvh & (di & 0x04) << 1;
-			di ^= nvh & (di & 0x08) << 1;
-			di ^= nvh & (di & 0x10) << 1;
-			di ^= nvh & (di & 0x20) << 1;
-			di ^= nvh & (di & 0x40) << 1;
-			d[i] = (byte)di;
-		}
-
-		di = ((nvh & (di & 0x80) << 1) ^ vi) >> 8;
-
-		/* initialize state */
-		set(yx[0], 1);
-		cpy(yx[1], p[di]);
-		cpy(yx[2], s[0]);
-		set(yz[0], 0);
-		set(yz[1], 1);
-		set(yz[2], 1);
-
-		/* y[0] is (even)P + (even)G
-		 * y[1] is (even)P + (odd)G  if current d-bit is 0
-		 * y[1] is (odd)P + (even)G  if current d-bit is 1
-		 * y[2] is (odd)P + (odd)G
-		 */
-
-		vi = 0;
-		hi = 0;
-
-		/* and go for it! */
-		for (i = 32; i--!=0; ) {
-			vi = (vi << 8) | (v[i] & 0xFF);
-			hi = (hi << 8) | (h[i] & 0xFF);
-			di = (di << 8) | (d[i] & 0xFF);
-
-			for (j = 8; j--!=0; ) {
-				mont_prep(t1[0], t2[0], yx[0], yz[0]);
-				mont_prep(t1[1], t2[1], yx[1], yz[1]);
-				mont_prep(t1[2], t2[2], yx[2], yz[2]);
-
-				k = ((vi ^ vi >> 1) >> j & 1)
-				  + ((hi ^ hi >> 1) >> j & 1);
-				mont_dbl(yx[2], yz[2], t1[k], t2[k], yx[0], yz[0]);
-
-				k = (di >> j & 2) ^ ((di >> j & 1) << 1);
-				mont_add(t1[1], t2[1], t1[k], t2[k], yx[1], yz[1],
-						p[di >> j & 1]);
-
-				mont_add(t1[2], t2[2], t1[0], t2[0], yx[2], yz[2],
-						s[((vi ^ hi) >> j & 2) >> 1]);
-			}
-		}
-
-		k = (vi & 1) + (hi & 1);
-		recip(t1[0], yz[k], 0);
-		mul(t1[1], yx[k], t1[0]);
-
-		pack(t1[1], Y);
-	}
-	
-	/////////////////////////////////////////////////////////////////////////// 
-	
-	/* sahn0:
-	 * Using this class instead of long[10] to avoid bounds checks. */
-	private static final class long10 {
-		public long10() {}
-		public long10(
-			long _0, long _1, long _2, long _3, long _4,
-			long _5, long _6, long _7, long _8, long _9)
-		{
-			this._0=_0; this._1=_1; this._2=_2;
-			this._3=_3; this._4=_4; this._5=_5;
-			this._6=_6; this._7=_7; this._8=_8;
-			this._9=_9;
-		}
-		public long _0,_1,_2,_3,_4,_5,_6,_7,_8,_9;
-	}
-	
-	/********************* radix 2^8 math *********************/
-	
-	private static final void cpy32(byte[] d, byte[] s) {
-		int i;
-		for (i = 0; i < 32; i++)
-			d[i] = s[i];
-	}
-	
-	/* p[m..n+m-1] = q[m..n+m-1] + z * x */
-	/* n is the size of x */
-	/* n+m is the size of p and q */
-	private static final int mula_small(byte[] p,byte[] q,int m,byte[] x,int n,int z) {
-		int v=0;
-		for (int i=0;i<n;++i) {
-			v+=(q[i+m] & 0xFF)+z*(x[i] & 0xFF);
-			p[i+m]=(byte)v;
-			v>>=8;
-		}
-		return v;		
-	}
-	
-	/* p += x * y * z  where z is a small integer
-	 * x is size 32, y is size t, p is size 32+t
-	 * y is allowed to overlap with p+32 if you don't care about the upper half  */
-	private static final int mula32(byte[] p, byte[] x, byte[] y, int t, int z) {
-		final int n = 31;
-		int w = 0;
-		int i = 0;
-		for (; i < t; i++) {
-			int zy = z * (y[i] & 0xFF);
-			w += mula_small(p, p, i, x, n, zy) +
-				(p[i+n] & 0xFF) + zy * (x[n] & 0xFF);
-			p[i+n] = (byte)w;
-			w >>= 8;
-		}
-		p[i+n] = (byte)(w + (p[i+n] & 0xFF));
-		return w >> 8;
-	}
-	
-	/* divide r (size n) by d (size t), returning quotient q and remainder r
-	 * quotient is size n-t+1, remainder is size t
-	 * requires t > 0 && d[t-1] != 0
-	 * requires that r[-1] and d[-1] are valid memory locations
-	 * q may overlap with r+t */
-	private static final void divmod(byte[] q, byte[] r, int n, byte[] d, int t) {
-		int rn = 0;
-		int dt = ((d[t-1] & 0xFF) << 8);
-		if (t>1) {
-			dt |= (d[t-2] & 0xFF);
-		}
-		while (n-- >= t) {
-			int z = (rn << 16) | ((r[n] & 0xFF) << 8);
-			if (n>0) {
-				z |= (r[n-1] & 0xFF);
-			}
-			z/=dt;
-			rn += mula_small(r,r, n-t+1, d, t, -z);
-			q[n-t+1] = (byte)((z + rn) & 0xFF); /* rn is 0 or -1 (underflow) */
-			mula_small(r,r, n-t+1, d, t, -rn);
-			rn = (r[n] & 0xFF);
-			r[n] = 0;
-		}
-		r[t-1] = (byte)rn;
-	}
-	
-	private static final int numsize(byte[] x,int n) {
-		while (n--!=0 && x[n]==0)
-			;
-		return n+1;
-	}
-	
-	/* Returns x if a contains the gcd, y if b.
-	 * Also, the returned buffer contains the inverse of a mod b,
-	 * as 32-byte signed.
-	 * x and y must have 64 bytes space for temporary use.
-	 * requires that a[-1] and b[-1] are valid memory locations  */
-	private static final byte[] egcd32(byte[] x,byte[] y,byte[] a,byte[] b) {
-		int an, bn = 32, qn, i;
-		for (i = 0; i < 32; i++)
-			x[i] = y[i] = 0;
-		x[0] = 1;
-		an = numsize(a, 32);
-		if (an==0)
-			return y;	/* division by zero */
-		byte[] temp=new byte[32];
-		while (true) {
-			qn = bn - an + 1;
-			divmod(temp, b, bn, a, an);
-			bn = numsize(b, bn);
-			if (bn==0)
-				return x;
-			mula32(y, x, temp, qn, -1);
-
-			qn = an - bn + 1;
-			divmod(temp, a, an, b, bn);
-			an = numsize(a, an);
-			if (an==0)
-				return y;
-			mula32(x, y, temp, qn, -1);
-		}
-	}
-	
-	/********************* radix 2^25.5 GF(2^255-19) math *********************/	
-	
-	private static final int P25=33554431;	/* (1 << 25) - 1 */
-	private static final int P26=67108863;	/* (1 << 26) - 1 */
-	
-	/* Convert to internal format from little-endian byte format */
-	private static final void unpack(long10 x,byte[] m) {
-		x._0 = ((m[0] & 0xFF))         | ((m[1] & 0xFF))<<8 |
-				(m[2] & 0xFF)<<16      | ((m[3] & 0xFF)& 3)<<24;
-		x._1 = ((m[3] & 0xFF)&~ 3)>>2  | (m[4] & 0xFF)<<6 |
-				(m[5] & 0xFF)<<14 | ((m[6] & 0xFF)& 7)<<22;
-		x._2 = ((m[6] & 0xFF)&~ 7)>>3  | (m[7] & 0xFF)<<5 |
-				(m[8] & 0xFF)<<13 | ((m[9] & 0xFF)&31)<<21;
-		x._3 = ((m[9] & 0xFF)&~31)>>5  | (m[10] & 0xFF)<<3 |
-				(m[11] & 0xFF)<<11 | ((m[12] & 0xFF)&63)<<19;
-		x._4 = ((m[12] & 0xFF)&~63)>>6 | (m[13] & 0xFF)<<2 |
-				(m[14] & 0xFF)<<10 |  (m[15] & 0xFF)    <<18;
-		x._5 =  (m[16] & 0xFF)         | (m[17] & 0xFF)<<8 |
-				(m[18] & 0xFF)<<16 | ((m[19] & 0xFF)& 1)<<24;
-		x._6 = ((m[19] & 0xFF)&~ 1)>>1 | (m[20] & 0xFF)<<7 |
-				(m[21] & 0xFF)<<15 | ((m[22] & 0xFF)& 7)<<23;
-		x._7 = ((m[22] & 0xFF)&~ 7)>>3 | (m[23] & 0xFF)<<5 |
-				(m[24] & 0xFF)<<13 | ((m[25] & 0xFF)&15)<<21;
-		x._8 = ((m[25] & 0xFF)&~15)>>4 | (m[26] & 0xFF)<<4 |
-				(m[27] & 0xFF)<<12 | ((m[28] & 0xFF)&63)<<20;
-		x._9 = ((m[28] & 0xFF)&~63)>>6 | (m[29] & 0xFF)<<2 |
-				(m[30] & 0xFF)<<10 |  (m[31] & 0xFF)    <<18;
-	}
-	
-	/* Check if reduced-form input >= 2^255-19 */
-	private static final boolean is_overflow(long10 x) {
-		return (
-			((x._0 > P26-19)) &&
-			((x._1 & x._3 & x._5 & x._7 & x._9) == P25) &&
-			((x._2 & x._4 & x._6 & x._8) == P26)
-			) || (x._9 > P25);
-	}
-	
-	/* Convert from internal format to little-endian byte format.  The 
-	 * number must be in a reduced form which is output by the following ops:
-	 *     unpack, mul, sqr
-	 *     set --  if input in range 0 .. P25
-	 * If you're unsure if the number is reduced, first multiply it by 1.  */
-	private static final void pack(long10 x,byte[] m) {
-		int ld = 0, ud = 0;
-		long t;
-		ld = (is_overflow(x)?1:0) - ((x._9 < 0)?1:0);
-		ud = ld * -(P25+1);
-		ld *= 19;
-		t = ld + x._0 + (x._1 << 26);
-		m[ 0] = (byte)t;
-		m[ 1] = (byte)(t >> 8);
-		m[ 2] = (byte)(t >> 16);
-		m[ 3] = (byte)(t >> 24);
-		t = (t >> 32) + (x._2 << 19);
-		m[ 4] = (byte)t;
-		m[ 5] = (byte)(t >> 8);
-		m[ 6] = (byte)(t >> 16);
-		m[ 7] = (byte)(t >> 24);
-		t = (t >> 32) + (x._3 << 13);
-		m[ 8] = (byte)t;
-		m[ 9] = (byte)(t >> 8);
-		m[10] = (byte)(t >> 16);
-		m[11] = (byte)(t >> 24);
-		t = (t >> 32) + (x._4 <<  6);
-		m[12] = (byte)t;
-		m[13] = (byte)(t >> 8);
-		m[14] = (byte)(t >> 16);
-		m[15] = (byte)(t >> 24);
-		t = (t >> 32) + x._5 + (x._6 << 25);
-		m[16] = (byte)t;
-		m[17] = (byte)(t >> 8);
-		m[18] = (byte)(t >> 16);
-		m[19] = (byte)(t >> 24);
-		t = (t >> 32) + (x._7 << 19);
-		m[20] = (byte)t;
-		m[21] = (byte)(t >> 8);
-		m[22] = (byte)(t >> 16);
-		m[23] = (byte)(t >> 24);
-		t = (t >> 32) + (x._8 << 12);
-		m[24] = (byte)t;
-		m[25] = (byte)(t >> 8);
-		m[26] = (byte)(t >> 16);
-		m[27] = (byte)(t >> 24);
-		t = (t >> 32) + ((x._9 + ud) << 6);
-		m[28] = (byte)t;
-		m[29] = (byte)(t >> 8);
-		m[30] = (byte)(t >> 16);
-		m[31] = (byte)(t >> 24);
-	}
-
-	/* Copy a number */
-	private static final void cpy(long10 out, long10 in) {
-		out._0=in._0;	out._1=in._1;
-		out._2=in._2;	out._3=in._3;
-		out._4=in._4;	out._5=in._5;
-		out._6=in._6;	out._7=in._7;
-		out._8=in._8;	out._9=in._9;		
-	}
-
-	/* Set a number to value, which must be in range -185861411 .. 185861411 */
-	private static final void set(long10 out, int in) {
-		out._0=in;	out._1=0;
-		out._2=0;	out._3=0;
-		out._4=0;	out._5=0;
-		out._6=0;	out._7=0;
-		out._8=0;	out._9=0;		
-	}
-	
-	/* Add/subtract two numbers.  The inputs must be in reduced form, and the 
-	 * output isn't, so to do another addition or subtraction on the output, 
-	 * first multiply it by one to reduce it. */
-	private static final void add(long10 xy, long10 x, long10 y) {
-		xy._0 = x._0 + y._0;	xy._1 = x._1 + y._1;
-		xy._2 = x._2 + y._2;	xy._3 = x._3 + y._3;
-		xy._4 = x._4 + y._4;	xy._5 = x._5 + y._5;
-		xy._6 = x._6 + y._6;	xy._7 = x._7 + y._7;
-		xy._8 = x._8 + y._8;	xy._9 = x._9 + y._9;
-	}
-	private static final void sub(long10 xy, long10 x, long10 y) {
-		xy._0 = x._0 - y._0;	xy._1 = x._1 - y._1;
-		xy._2 = x._2 - y._2;	xy._3 = x._3 - y._3;
-		xy._4 = x._4 - y._4;	xy._5 = x._5 - y._5;
-		xy._6 = x._6 - y._6;	xy._7 = x._7 - y._7;
-		xy._8 = x._8 - y._8;	xy._9 = x._9 - y._9;
-	}
-	
-	/* Multiply a number by a small integer in range -185861411 .. 185861411.
-	 * The output is in reduced form, the input x need not be.  x and xy may point
-	 * to the same buffer. */
-	private static final long10 mul_small(long10 xy, long10 x, long y) {
-		long t;
-		t = (x._8*y);
-		xy._8 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + (x._9*y);
-		xy._9 = (t & ((1 << 25) - 1));
-		t = 19 * (t >> 25) + (x._0*y);
-		xy._0 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + (x._1*y);
-		xy._1 = (t & ((1 << 25) - 1));
-		t = (t >> 25) + (x._2*y);
-		xy._2 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + (x._3*y);
-		xy._3 = (t & ((1 << 25) - 1));
-		t = (t >> 25) + (x._4*y);
-		xy._4 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + (x._5*y);
-		xy._5 = (t & ((1 << 25) - 1));
-		t = (t >> 25) + (x._6*y);
-		xy._6 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + (x._7*y);
-		xy._7 = (t & ((1 << 25) - 1));
-		t = (t >> 25) + xy._8;
-		xy._8 = (t & ((1 << 26) - 1));
-		xy._9 += (t >> 26);
-		return xy;
-	}
-
-	/* Multiply two numbers.  The output is in reduced form, the inputs need not 
-	 * be. */
-	private static final long10 mul(long10 xy, long10 x, long10 y) {
-		/* sahn0:
-		 * Using local variables to avoid class access.
-		 * This seem to improve performance a bit...
-		 */
-		long
-			x_0=x._0,x_1=x._1,x_2=x._2,x_3=x._3,x_4=x._4,
-			x_5=x._5,x_6=x._6,x_7=x._7,x_8=x._8,x_9=x._9;
-		long
-			y_0=y._0,y_1=y._1,y_2=y._2,y_3=y._3,y_4=y._4,
-			y_5=y._5,y_6=y._6,y_7=y._7,y_8=y._8,y_9=y._9;
-		long t;
-		t = (x_0*y_8) + (x_2*y_6) + (x_4*y_4) + (x_6*y_2) +
-			(x_8*y_0) + 2 * ((x_1*y_7) + (x_3*y_5) +
-					(x_5*y_3) + (x_7*y_1)) + 38 *
-			(x_9*y_9);
-		xy._8 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + (x_0*y_9) + (x_1*y_8) + (x_2*y_7) +
-			(x_3*y_6) + (x_4*y_5) + (x_5*y_4) +
-			(x_6*y_3) + (x_7*y_2) + (x_8*y_1) +
-			(x_9*y_0);
-		xy._9 = (t & ((1 << 25) - 1));
-		t = (x_0*y_0) + 19 * ((t >> 25) + (x_2*y_8) + (x_4*y_6)
-				+ (x_6*y_4) + (x_8*y_2)) + 38 *
-			((x_1*y_9) + (x_3*y_7) + (x_5*y_5) +
-			 (x_7*y_3) + (x_9*y_1));
-		xy._0 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + (x_0*y_1) + (x_1*y_0) + 19 * ((x_2*y_9)
-				+ (x_3*y_8) + (x_4*y_7) + (x_5*y_6) +
-				(x_6*y_5) + (x_7*y_4) + (x_8*y_3) +
-				(x_9*y_2));
-		xy._1 = (t & ((1 << 25) - 1));
-		t = (t >> 25) + (x_0*y_2) + (x_2*y_0) + 19 * ((x_4*y_8)
-				+ (x_6*y_6) + (x_8*y_4)) + 2 * (x_1*y_1)
-				+ 38 * ((x_3*y_9) + (x_5*y_7) +
-						(x_7*y_5) + (x_9*y_3));
-		xy._2 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + (x_0*y_3) + (x_1*y_2) + (x_2*y_1) +
-			(x_3*y_0) + 19 * ((x_4*y_9) + (x_5*y_8) +
-					(x_6*y_7) + (x_7*y_6) +
-					(x_8*y_5) + (x_9*y_4));
-		xy._3 = (t & ((1 << 25) - 1));
-		t = (t >> 25) + (x_0*y_4) + (x_2*y_2) + (x_4*y_0) + 19 *
-			((x_6*y_8) + (x_8*y_6)) + 2 * ((x_1*y_3) +
-								 (x_3*y_1)) + 38 *
-			((x_5*y_9) + (x_7*y_7) + (x_9*y_5));
-		xy._4 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + (x_0*y_5) + (x_1*y_4) + (x_2*y_3) +
-			(x_3*y_2) + (x_4*y_1) + (x_5*y_0) + 19 *
-			((x_6*y_9) + (x_7*y_8) + (x_8*y_7) +
-			 (x_9*y_6));
-		xy._5 = (t & ((1 << 25) - 1));
-		t = (t >> 25) + (x_0*y_6) + (x_2*y_4) + (x_4*y_2) +
-			(x_6*y_0) + 19 * (x_8*y_8) + 2 * ((x_1*y_5) +
-					(x_3*y_3) + (x_5*y_1)) + 38 *
-			((x_7*y_9) + (x_9*y_7));
-		xy._6 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + (x_0*y_7) + (x_1*y_6) + (x_2*y_5) +
-			(x_3*y_4) + (x_4*y_3) + (x_5*y_2) +
-			(x_6*y_1) + (x_7*y_0) + 19 * ((x_8*y_9) +
-					(x_9*y_8));
-		xy._7 = (t & ((1 << 25) - 1));
-		t = (t >> 25) + xy._8;
-		xy._8 = (t & ((1 << 26) - 1));
-		xy._9 += (t >> 26);
-		return xy;
-	}
-
-	/* Square a number.  Optimization of  mul25519(x2, x, x)  */
-	private static final long10 sqr(long10 x2, long10 x) {
-		long
-			x_0=x._0,x_1=x._1,x_2=x._2,x_3=x._3,x_4=x._4,
-			x_5=x._5,x_6=x._6,x_7=x._7,x_8=x._8,x_9=x._9;
-		long t;
-		t = (x_4*x_4) + 2 * ((x_0*x_8) + (x_2*x_6)) + 38 *
-			(x_9*x_9) + 4 * ((x_1*x_7) + (x_3*x_5));
-		x2._8 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + 2 * ((x_0*x_9) + (x_1*x_8) + (x_2*x_7) +
-				(x_3*x_6) + (x_4*x_5));
-		x2._9 = (t & ((1 << 25) - 1));
-		t = 19 * (t >> 25) + (x_0*x_0) + 38 * ((x_2*x_8) +
-				(x_4*x_6) + (x_5*x_5)) + 76 * ((x_1*x_9)
-				+ (x_3*x_7));
-		x2._0 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + 2 * (x_0*x_1) + 38 * ((x_2*x_9) +
-				(x_3*x_8) + (x_4*x_7) + (x_5*x_6));
-		x2._1 = (t & ((1 << 25) - 1));
-		t = (t >> 25) + 19 * (x_6*x_6) + 2 * ((x_0*x_2) +
-				(x_1*x_1)) + 38 * (x_4*x_8) + 76 *
-				((x_3*x_9) + (x_5*x_7));
-		x2._2 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + 2 * ((x_0*x_3) + (x_1*x_2)) + 38 *
-			((x_4*x_9) + (x_5*x_8) + (x_6*x_7));
-		x2._3 = (t & ((1 << 25) - 1));
-		t = (t >> 25) + (x_2*x_2) + 2 * (x_0*x_4) + 38 *
-			((x_6*x_8) + (x_7*x_7)) + 4 * (x_1*x_3) + 76 *
-			(x_5*x_9);
-		x2._4 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + 2 * ((x_0*x_5) + (x_1*x_4) + (x_2*x_3))
-			+ 38 * ((x_6*x_9) + (x_7*x_8));
-		x2._5 = (t & ((1 << 25) - 1));
-		t = (t >> 25) + 19 * (x_8*x_8) + 2 * ((x_0*x_6) +
-				(x_2*x_4) + (x_3*x_3)) + 4 * (x_1*x_5) +
-				76 * (x_7*x_9);
-		x2._6 = (t & ((1 << 26) - 1));
-		t = (t >> 26) + 2 * ((x_0*x_7) + (x_1*x_6) + (x_2*x_5) +
-				(x_3*x_4)) + 38 * (x_8*x_9);
-		x2._7 = (t & ((1 << 25) - 1));
-		t = (t >> 25) + x2._8;
-		x2._8 = (t & ((1 << 26) - 1));
-		x2._9 += (t >> 26);
-		return x2;
-	}
-	
-	/* Calculates a reciprocal.  The output is in reduced form, the inputs need not 
-	 * be.  Simply calculates  y = x^(p-2)  so it's not too fast. */
-	/* When sqrtassist is true, it instead calculates y = x^((p-5)/8) */
-	private static final void recip(long10 y, long10 x, int sqrtassist) {
-		long10
-		    t0=new long10(),
-			t1=new long10(),
-			t2=new long10(),
-			t3=new long10(),
-			t4=new long10();
-		int i;
-		/* the chain for x^(2^255-21) is straight from djb's implementation */
-		sqr(t1, x);	/*  2 == 2 * 1	*/
-		sqr(t2, t1);	/*  4 == 2 * 2	*/
-		sqr(t0, t2);	/*  8 == 2 * 4	*/
-		mul(t2, t0, x);	/*  9 == 8 + 1	*/
-		mul(t0, t2, t1);	/* 11 == 9 + 2	*/
-		sqr(t1, t0);	/* 22 == 2 * 11	*/
-		mul(t3, t1, t2);	/* 31 == 22 + 9
-					== 2^5   - 2^0	*/
-		sqr(t1, t3);	/* 2^6   - 2^1	*/
-		sqr(t2, t1);	/* 2^7   - 2^2	*/
-		sqr(t1, t2);	/* 2^8   - 2^3	*/
-		sqr(t2, t1);	/* 2^9   - 2^4	*/
-		sqr(t1, t2);	/* 2^10  - 2^5	*/
-		mul(t2, t1, t3);	/* 2^10  - 2^0	*/
-		sqr(t1, t2);	/* 2^11  - 2^1	*/
-		sqr(t3, t1);	/* 2^12  - 2^2	*/
-		for (i = 1; i < 5; i++) {
-			sqr(t1, t3);
-			sqr(t3, t1);
-		} /* t3 */		/* 2^20  - 2^10	*/
-		mul(t1, t3, t2);	/* 2^20  - 2^0	*/
-		sqr(t3, t1);	/* 2^21  - 2^1	*/
-		sqr(t4, t3);	/* 2^22  - 2^2	*/
-		for (i = 1; i < 10; i++) {
-			sqr(t3, t4);
-			sqr(t4, t3);
-		} /* t4 */		/* 2^40  - 2^20	*/
-		mul(t3, t4, t1);	/* 2^40  - 2^0	*/
-		for (i = 0; i < 5; i++) {
-			sqr(t1, t3);
-			sqr(t3, t1);
-		} /* t3 */		/* 2^50  - 2^10	*/
-		mul(t1, t3, t2);	/* 2^50  - 2^0	*/
-		sqr(t2, t1);	/* 2^51  - 2^1	*/
-		sqr(t3, t2);	/* 2^52  - 2^2	*/
-		for (i = 1; i < 25; i++) {
-			sqr(t2, t3);
-			sqr(t3, t2);
-		} /* t3 */		/* 2^100 - 2^50 */
-		mul(t2, t3, t1);	/* 2^100 - 2^0	*/
-		sqr(t3, t2);	/* 2^101 - 2^1	*/
-		sqr(t4, t3);	/* 2^102 - 2^2	*/
-		for (i = 1; i < 50; i++) {
-			sqr(t3, t4);
-			sqr(t4, t3);
-		} /* t4 */		/* 2^200 - 2^100 */
-		mul(t3, t4, t2);	/* 2^200 - 2^0	*/
-		for (i = 0; i < 25; i++) {
-			sqr(t4, t3);
-			sqr(t3, t4);
-		} /* t3 */		/* 2^250 - 2^50	*/
-		mul(t2, t3, t1);	/* 2^250 - 2^0	*/
-		sqr(t1, t2);	/* 2^251 - 2^1	*/
-		sqr(t2, t1);	/* 2^252 - 2^2	*/
-		if (sqrtassist!=0) {
-			mul(y, x, t2);	/* 2^252 - 3 */
-		} else {
-			sqr(t1, t2);	/* 2^253 - 2^3	*/
-			sqr(t2, t1);	/* 2^254 - 2^4	*/
-			sqr(t1, t2);	/* 2^255 - 2^5	*/
-			mul(y, t1, t0);	/* 2^255 - 21	*/
-		}
-	}
-	
-	/* checks if x is "negative", requires reduced input */
-	private static final int is_negative(long10 x) {
-		return (int)(((is_overflow(x) || (x._9 < 0))?1:0) ^ (x._0 & 1));
-	}
-	
-	/* a square root */
-	private static final void sqrt(long10 x, long10 u) {
-		long10 v=new long10(), t1=new long10(), t2=new long10();
-		add(t1, u, u);	/* t1 = 2u		*/
-		recip(v, t1, 1);	/* v = (2u)^((p-5)/8)	*/
-		sqr(x, v);		/* x = v^2		*/
-		mul(t2, t1, x);	/* t2 = 2uv^2		*/
-		t2._0--;		/* t2 = 2uv^2-1		*/
-		mul(t1, v, t2);	/* t1 = v(2uv^2-1)	*/
-		mul(x, u, t1);	/* x = uv(2uv^2-1)	*/
-	}
-	
-	/********************* Elliptic curve *********************/
-	
-	/* y^2 = x^3 + 486662 x^2 + x  over GF(2^255-19) */
-	
-	/* t1 = ax + az
-	 * t2 = ax - az  */
-	private static final void mont_prep(long10 t1, long10 t2, long10 ax, long10 az) {
-		add(t1, ax, az);
-		sub(t2, ax, az);
-	}
-	
-	/* A = P + Q   where
-	 *  X(A) = ax/az
-	 *  X(P) = (t1+t2)/(t1-t2)
-	 *  X(Q) = (t3+t4)/(t3-t4)
-	 *  X(P-Q) = dx
-	 * clobbers t1 and t2, preserves t3 and t4  */
-	private static final void mont_add(long10 t1, long10 t2, long10 t3, long10 t4,long10 ax, long10 az, long10 dx) {
-		mul(ax, t2, t3);
-		mul(az, t1, t4);
-		add(t1, ax, az);
-		sub(t2, ax, az);
-		sqr(ax, t1);
-		sqr(t1, t2);
-		mul(az, t1, dx);
-	}
-	
-	/* B = 2 * Q   where
-	 *  X(B) = bx/bz
-	 *  X(Q) = (t3+t4)/(t3-t4)
-	 * clobbers t1 and t2, preserves t3 and t4  */
-	private static final void mont_dbl(long10 t1, long10 t2, long10 t3, long10 t4,long10 bx, long10 bz) {
-		sqr(t1, t3);
-		sqr(t2, t4);
-		mul(bx, t1, t2);
-		sub(t2, t1, t2);
-		mul_small(bz, t2, 121665);
-		add(t1, t1, bz);
-		mul(bz, t1, t2);
-	}
-	
-	/* Y^2 = X^3 + 486662 X^2 + X
-	 * t is a temporary  */
-	private static final void x_to_y2(long10 t, long10 y2, long10 x) {
-		sqr(t, x);
-		mul_small(y2, x, 486662);
-		add(t, t, y2);
-		t._0++;
-		mul(y2, t, x);
-	}
-	
-	/* P = kG   and  s = sign(P)/k  */
-	private static final void core(byte[] Px, byte[] s, byte[] k, byte[] Gx) {
-		long10 
-		    dx=new long10(),
-		    t1=new long10(),
-		    t2=new long10(),
-		    t3=new long10(),
-		    t4=new long10();
-	    long10[] 
-	        x=new long10[]{new long10(),new long10()},
-	    	z=new long10[]{new long10(),new long10()};
-		int i, j;
-
-		/* unpack the base */
-		if (Gx!=null)
-			unpack(dx, Gx);
-		else
-			set(dx, 9);
-
-		/* 0G = point-at-infinity */
-		set(x[0], 1);
-		set(z[0], 0);
-
-		/* 1G = G */
-		cpy(x[1], dx);
-		set(z[1], 1);
-
-		for (i = 32; i--!=0; ) {
-			if (i==0) {
-				i=0;
-			}
-			for (j = 8; j--!=0; ) {
-				/* swap arguments depending on bit */
-				int bit1 = (k[i] & 0xFF) >> j & 1;
-				int bit0 = ~(k[i] & 0xFF) >> j & 1;
-				long10 ax = x[bit0];
-				long10 az = z[bit0];
-				long10 bx = x[bit1];
-				long10 bz = z[bit1];
-
-				/* a' = a + b	*/
-				/* b' = 2 b	*/
-				mont_prep(t1, t2, ax, az);
-				mont_prep(t3, t4, bx, bz);
-				mont_add(t1, t2, t3, t4, ax, az, dx);
-				mont_dbl(t1, t2, t3, t4, bx, bz);
-			}
-		}
-
-		recip(t1, z[0], 0);
-		mul(dx, x[0], t1);
-		pack(dx, Px);
-
-		/* calculate s such that s abs(P) = G  .. assumes G is std base point */
-		if (s!=null) {
-			x_to_y2(t2, t1, dx);	/* t1 = Py^2  */
-			recip(t3, z[1], 0);	/* where Q=P+G ... */
-			mul(t2, x[1], t3);	/* t2 = Qx  */
-			add(t2, t2, dx);	/* t2 = Qx + Px  */
-			t2._0 += 9 + 486662;	/* t2 = Qx + Px + Gx + 486662  */
-			dx._0 -= 9;		/* dx = Px - Gx  */
-			sqr(t3, dx);	/* t3 = (Px - Gx)^2  */
-			mul(dx, t2, t3);	/* dx = t2 (Px - Gx)^2  */
-			sub(dx, dx, t1);	/* dx = t2 (Px - Gx)^2 - Py^2  */
-			dx._0 -= 39420360;	/* dx = t2 (Px - Gx)^2 - Py^2 - Gy^2  */
-			mul(t1, dx, BASE_R2Y);	/* t1 = -Py  */
-			if (is_negative(t1)!=0)	/* sign is 1, so just copy  */
-				cpy32(s, k);
-			else			/* sign is -1, so negate  */
-				mula_small(s, ORDER_TIMES_8, 0, k, 32, -1);
-
-			/* reduce s mod q
-			 * (is this needed?  do it just in case, it's fast anyway) */
-			//divmod((dstptr) t1, s, 32, order25519, 32);
-
-			/* take reciprocal of s mod q */
-			byte[] temp1=new byte[32];
-			byte[] temp2=new byte[64];
-			byte[] temp3=new byte[64];
-			cpy32(temp1, ORDER);
-			cpy32(s, egcd32(temp2, temp3, s, temp1));
-			if ((s[31] & 0x80)!=0)
-				mula_small(s, s, 0, ORDER, 32, 1);
-		}
-	}
-
-	/* smallest multiple of the order that's >= 2^255 */
-	private static final byte[] ORDER_TIMES_8 = {
-		(byte)104, (byte)159, (byte)174, (byte)231,
-		(byte)210, (byte)24,  (byte)147, (byte)192,
-		(byte)178, (byte)230, (byte)188, (byte)23,
-		(byte)245, (byte)206, (byte)247, (byte)166,
-		(byte)0,   (byte)0,   (byte)0,   (byte)0,  
-		(byte)0,   (byte)0,   (byte)0,   (byte)0,
-		(byte)0,   (byte)0,   (byte)0,   (byte)0,  
-		(byte)0,   (byte)0,   (byte)0,   (byte)128
-	};
-	
-	/* constants 2Gy and 1/(2Gy) */
-	private static final long10 BASE_2Y = new long10(
-		39999547, 18689728, 59995525, 1648697, 57546132,
-		24010086, 19059592, 5425144, 63499247, 16420658
-	);
-	private static final long10 BASE_R2Y = new long10(
-		5744, 8160848, 4790893, 13779497, 35730846,
-		12541209, 49101323, 30047407, 40071253, 6226132
-	);
-}

src/main/java/net/schmizz/concurrent/Promise.java

@@ -136,7 +136,7 @@ public class Promise<V, T extends Throwable> {
             throws T {
         final V value = tryRetrieve(timeout, unit);
         if (value == null)
-            throw chainer.chain(new TimeoutException("Timeout expired"));
+            throw chainer.chain(new TimeoutException("Timeout expired: " + timeout + " " + unit));
         else
             return value;
     }
@@ -176,6 +176,7 @@ public class Promise<V, T extends Throwable> {
             }
             return val;
         } catch (InterruptedException ie) {
+            Thread.currentThread().interrupt();
             throw chainer.chain(ie);
         } finally {
             lock.unlock();

src/main/java/net/schmizz/keepalive/Heartbeater.java

@@ -24,7 +24,7 @@ final class Heartbeater
         extends KeepAlive {
 
     Heartbeater(ConnectionImpl conn) {
-        super(conn, "heartbeater");
+        super(conn, "sshj-Heartbeater");
     }
 
     @Override

src/main/java/net/schmizz/keepalive/KeepAlive.java

@@ -20,6 +20,8 @@ import net.schmizz.sshj.connection.ConnectionImpl;
 import net.schmizz.sshj.transport.TransportException;
 import org.slf4j.Logger;
 
+import java.util.concurrent.TimeUnit;
+
 public abstract class KeepAlive extends Thread {
     protected final Logger log;
     protected final ConnectionImpl conn;
@@ -33,40 +35,49 @@ public abstract class KeepAlive extends Thread {
         setDaemon(true);
     }
 
+    /**
+     * KeepAlive enabled based on KeepAlive interval
+     *
+     * @return Enabled when KeepInterval is greater than 0
+     */
+    public boolean isEnabled() {
+        return keepAliveInterval > 0;
+    }
+
+    /**
+     * Get KeepAlive interval in seconds
+     *
+     * @return KeepAlive interval in seconds defaults to 0
+     */
     public synchronized int getKeepAliveInterval() {
         return keepAliveInterval;
     }
 
+    /**
+     * Set KeepAlive interval in seconds
+     *
+     * @param keepAliveInterval KeepAlive interval in seconds
+     */
     public synchronized void setKeepAliveInterval(int keepAliveInterval) {
         this.keepAliveInterval = keepAliveInterval;
-        if (keepAliveInterval > 0 && getState() == State.NEW) {
-            start();
-        }
-        notify();
-    }
-
-    synchronized protected int getPositiveInterval()
-            throws InterruptedException {
-        while (keepAliveInterval <= 0) {
-            wait();
-        }
-        return keepAliveInterval;
     }
 
     @Override
     public void run() {
-        log.debug("Starting {}, sending keep-alive every {} seconds", getClass().getSimpleName(), keepAliveInterval);
+        log.debug("{} Started with interval [{} seconds]", getClass().getSimpleName(), keepAliveInterval);
         try {
             while (!isInterrupted()) {
-                final int hi = getPositiveInterval();
+                final int interval = getKeepAliveInterval();
                 if (conn.getTransport().isRunning()) {
-                    log.debug("Sending keep-alive since {} seconds elapsed", hi);
+                    log.debug("{} Sending after interval [{} seconds]", getClass().getSimpleName(), interval);
                     doKeepAlive();
                 }
-                Thread.sleep(hi * 1000);
+                TimeUnit.SECONDS.sleep(interval);
             }
         } catch (InterruptedException e) {
-            // Interrupt signal may be catched when sleeping.      
+            // this is almost certainly a planned interruption, but even so, no harm in setting the interrupt flag
+            Thread.currentThread().interrupt();
+            log.trace("{} Interrupted while sleeping", getClass().getSimpleName());
         } catch (Exception e) {
             // If we weren't interrupted, kill the transport, then this exception was unexpected.
             // Else we're in shutdown-mode already, so don't forcibly kill the transport.
@@ -74,9 +85,7 @@ public abstract class KeepAlive extends Thread {
                 conn.getTransport().die(e);
             }
         }
-
-        log.debug("Stopping {}", getClass().getSimpleName());
-
+        log.debug("{} Stopped", getClass().getSimpleName());
     }
 
     protected abstract void doKeepAlive() throws TransportException, ConnectionException;

src/main/java/net/schmizz/keepalive/KeepAliveRunner.java

@@ -37,7 +37,7 @@ public class KeepAliveRunner extends KeepAlive {
             new LinkedList<Promise<SSHPacket, ConnectionException>>();
 
     KeepAliveRunner(ConnectionImpl conn) {
-        super(conn, "keep-alive");
+        super(conn, "sshj-KeepAliveRunner");
     }
 
     synchronized public int getMaxAliveCount() {

src/main/java/net/schmizz/sshj/AndroidConfig.java

@@ -19,8 +19,6 @@ import com.hierynomus.sshj.key.KeyAlgorithm;
 import com.hierynomus.sshj.key.KeyAlgorithms;
 import net.schmizz.sshj.common.Factory;
 import net.schmizz.sshj.common.SecurityUtils;
-import net.schmizz.sshj.transport.random.JCERandom;
-import net.schmizz.sshj.transport.random.SingletonRandomFactory;
 
 import java.util.Arrays;
 
@@ -34,7 +32,6 @@ public class AndroidConfig
         SecurityUtils.registerSecurityProvider("org.spongycastle.jce.provider.BouncyCastleProvider");
     }
 
-
     @Override
     protected void initKeyAlgorithms() {
         setKeyAlgorithms(Arrays.<Factory.Named<KeyAlgorithm>>asList(
@@ -43,10 +40,4 @@ public class AndroidConfig
                 KeyAlgorithms.SSHDSA()
         ));
     }
-
-    @Override
-    protected void initRandomFactory(boolean ignored) {
-        setRandomFactory(new SingletonRandomFactory(new JCERandom.Factory()));
-    }
-
 }

src/main/java/net/schmizz/sshj/Config.java

@@ -200,4 +200,8 @@ public interface Config {
      * See {@link #isVerifyHostKeyCertificates()}.
      */
     void setVerifyHostKeyCertificates(boolean value);
+
+    int getMaxCircularBufferSize();
+
+    void setMaxCircularBufferSize(int maxCircularBufferSize);
 }

src/main/java/net/schmizz/sshj/ConfigImpl.java

@@ -26,6 +26,7 @@ import net.schmizz.sshj.transport.mac.MAC;
 import net.schmizz.sshj.transport.random.Random;
 import net.schmizz.sshj.userauth.keyprovider.FileKeyProvider;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
@@ -48,6 +49,8 @@ public class ConfigImpl
     private boolean waitForServerIdentBeforeSendingClientIdent = false;
     private LoggerFactory loggerFactory;
     private boolean verifyHostKeyCertificates = true;
+    // HF-982: default to 16MB buffers.
+    private int maxCircularBufferSize = 16 * 1024 * 1024;
 
     @Override
     public List<Factory.Named<Cipher>> getCipherFactories() {
@@ -174,6 +177,16 @@ public class ConfigImpl
         return loggerFactory;
     }
 
+    @Override
+    public int getMaxCircularBufferSize() {
+        return maxCircularBufferSize;
+    }
+
+    @Override
+    public void setMaxCircularBufferSize(int maxCircularBufferSize) {
+        this.maxCircularBufferSize = maxCircularBufferSize;
+    }
+
     @Override
     public void setLoggerFactory(LoggerFactory loggerFactory) {
         this.loggerFactory = loggerFactory;
@@ -188,4 +201,30 @@ public class ConfigImpl
     public void setVerifyHostKeyCertificates(boolean value) {
         verifyHostKeyCertificates = value;
     }
+
+    /**
+     * Modern servers neglect the key algorithm ssh-rsa. OpenSSH 8.8 even dropped its support by default in favour
+     * of rsa-sha2-*. However, there are legacy servers like Apache SSHD that don't support the newer replacements
+     * for ssh-rsa.
+     *
+     * If ssh-rsa factory is in {@link #getKeyAlgorithms()}, this methods makes ssh-rsa key algorithm more preferred
+     * than any of rsa-sha2-*. Otherwise, nothing happens.
+     */
+    public void prioritizeSshRsaKeyAlgorithm() {
+        List<Factory.Named<KeyAlgorithm>> keyAlgorithms = getKeyAlgorithms();
+        for (int sshRsaIndex = 0; sshRsaIndex < keyAlgorithms.size(); ++ sshRsaIndex) {
+            if ("ssh-rsa".equals(keyAlgorithms.get(sshRsaIndex).getName())) {
+                for (int i = 0; i < sshRsaIndex; ++i) {
+                    final String algo = keyAlgorithms.get(i).getName();
+                    if ("rsa-sha2-256".equals(algo) || "rsa-sha2-512".equals(algo)) {
+                        keyAlgorithms = new ArrayList<>(keyAlgorithms);
+                        keyAlgorithms.add(i, keyAlgorithms.remove(sshRsaIndex));
+                        setKeyAlgorithms(keyAlgorithms);
+                        break;
+                    }
+                }
+                break;
+            }
+        }
+    }
 }

src/main/java/net/schmizz/sshj/DefaultConfig.java

@@ -29,23 +29,24 @@ import com.hierynomus.sshj.userauth.keyprovider.OpenSSHKeyV1KeyFile;
 import net.schmizz.keepalive.KeepAliveProvider;
 import net.schmizz.sshj.common.Factory;
 import net.schmizz.sshj.common.LoggerFactory;
-import net.schmizz.sshj.common.SecurityUtils;
 import net.schmizz.sshj.transport.cipher.Cipher;
 import net.schmizz.sshj.transport.compression.NoneCompression;
 import net.schmizz.sshj.transport.kex.Curve25519SHA256;
 import net.schmizz.sshj.transport.kex.DHGexSHA1;
 import net.schmizz.sshj.transport.kex.DHGexSHA256;
 import net.schmizz.sshj.transport.kex.ECDHNistP;
-import net.schmizz.sshj.transport.random.BouncyCastleRandom;
 import net.schmizz.sshj.transport.random.JCERandom;
 import net.schmizz.sshj.transport.random.SingletonRandomFactory;
 import net.schmizz.sshj.userauth.keyprovider.OpenSSHKeyFile;
-import net.schmizz.sshj.userauth.keyprovider.PKCS5KeyFile;
 import net.schmizz.sshj.userauth.keyprovider.PKCS8KeyFile;
 import net.schmizz.sshj.userauth.keyprovider.PuTTYKeyFile;
 import org.slf4j.Logger;
 
-import java.util.*;
+import java.util.Arrays;
+import java.util.List;
+import java.util.LinkedList;
+import java.util.ListIterator;
+import java.util.Properties;
 
 /**
  * A {@link net.schmizz.sshj.Config} that is initialized as follows. Items marked with an asterisk are added to the config only if
@@ -64,8 +65,6 @@ import java.util.*;
  * <li>{@link net.schmizz.sshj.ConfigImpl#setVersion Client version}: {@code "NET_3_0"}</li>
  * </ul>
  * <p/>
- * [1] It is worth noting that Sun's JRE does not have the unlimited cryptography extension enabled by default. This
- * prevents using ciphers with strength greater than 128.
  */
 public class DefaultConfig
         extends ConfigImpl {
@@ -75,11 +74,10 @@ public class DefaultConfig
     public DefaultConfig() {
         setLoggerFactory(LoggerFactory.DEFAULT);
         setVersion(readVersionFromProperties());
-        final boolean bouncyCastleRegistered = SecurityUtils.isBouncyCastleRegistered();
-        initKeyExchangeFactories(bouncyCastleRegistered);
+        initKeyExchangeFactories();
         initKeyAlgorithms();
-        initRandomFactory(bouncyCastleRegistered);
-        initFileKeyProviderFactories(bouncyCastleRegistered);
+        initRandomFactory();
+        initFileKeyProviderFactories();
         initCipherFactories();
         initCompressionFactories();
         initMACFactories();
@@ -104,35 +102,32 @@ public class DefaultConfig
         log = loggerFactory.getLogger(getClass());
     }
 
-    protected void initKeyExchangeFactories(boolean bouncyCastleRegistered) {
-        if (bouncyCastleRegistered) {
-            setKeyExchangeFactories(
-                    new Curve25519SHA256.Factory(),
-                    new Curve25519SHA256.FactoryLibSsh(),
-                    new DHGexSHA256.Factory(),
-                    new ECDHNistP.Factory521(),
-                    new ECDHNistP.Factory384(),
-                    new ECDHNistP.Factory256(),
-                    new DHGexSHA1.Factory(),
-                    DHGroups.Group1SHA1(),
-                    DHGroups.Group14SHA1(),
-                    DHGroups.Group14SHA256(),
-                    DHGroups.Group15SHA512(),
-                    DHGroups.Group16SHA512(),
-                    DHGroups.Group17SHA512(),
-                    DHGroups.Group18SHA512(),
-                    ExtendedDHGroups.Group14SHA256AtSSH(),
-                    ExtendedDHGroups.Group15SHA256(),
-                    ExtendedDHGroups.Group15SHA256AtSSH(),
-                    ExtendedDHGroups.Group15SHA384AtSSH(),
-                    ExtendedDHGroups.Group16SHA256(),
-                    ExtendedDHGroups.Group16SHA384AtSSH(),
-                    ExtendedDHGroups.Group16SHA512AtSSH(),
-                    ExtendedDHGroups.Group18SHA512AtSSH(),
-                    new ExtInfoClientFactory());
-        } else {
-            setKeyExchangeFactories(DHGroups.Group1SHA1(), new DHGexSHA1.Factory());
-        }
+    protected void initKeyExchangeFactories() {
+        setKeyExchangeFactories(
+                new Curve25519SHA256.Factory(),
+                new Curve25519SHA256.FactoryLibSsh(),
+                new DHGexSHA256.Factory(),
+                new ECDHNistP.Factory521(),
+                new ECDHNistP.Factory384(),
+                new ECDHNistP.Factory256(),
+                new DHGexSHA1.Factory(),
+                DHGroups.Group1SHA1(),
+                DHGroups.Group14SHA1(),
+                DHGroups.Group14SHA256(),
+                DHGroups.Group15SHA512(),
+                DHGroups.Group16SHA512(),
+                DHGroups.Group17SHA512(),
+                DHGroups.Group18SHA512(),
+                ExtendedDHGroups.Group14SHA256AtSSH(),
+                ExtendedDHGroups.Group15SHA256(),
+                ExtendedDHGroups.Group15SHA256AtSSH(),
+                ExtendedDHGroups.Group15SHA384AtSSH(),
+                ExtendedDHGroups.Group16SHA256(),
+                ExtendedDHGroups.Group16SHA384AtSSH(),
+                ExtendedDHGroups.Group16SHA512AtSSH(),
+                ExtendedDHGroups.Group18SHA512AtSSH(),
+                new ExtInfoClientFactory()
+        );
     }
 
     protected void initKeyAlgorithms() {
@@ -153,22 +148,19 @@ public class DefaultConfig
                 KeyAlgorithms.SSHDSA()));
     }
 
-    protected void initRandomFactory(boolean bouncyCastleRegistered) {
+    protected void initRandomFactory() {
         setRandomFactory(new SingletonRandomFactory(new JCERandom.Factory()));
     }
 
-    protected void initFileKeyProviderFactories(boolean bouncyCastleRegistered) {
-        if (bouncyCastleRegistered) {
-            setFileKeyProviderFactories(
-                    new OpenSSHKeyV1KeyFile.Factory(),
-                    new PKCS8KeyFile.Factory(),
-                    new PKCS5KeyFile.Factory(),
-                    new OpenSSHKeyFile.Factory(),
-                    new PuTTYKeyFile.Factory());
-        }
+    protected void initFileKeyProviderFactories() {
+        setFileKeyProviderFactories(
+                new OpenSSHKeyV1KeyFile.Factory(),
+                new PKCS8KeyFile.Factory(),
+                new OpenSSHKeyFile.Factory(),
+                new PuTTYKeyFile.Factory()
+        );
     }
 
-
     protected void initCipherFactories() {
         List<Factory.Named<Cipher>> avail = new LinkedList<Factory.Named<Cipher>>(Arrays.<Factory.Named<Cipher>>asList(
                 ChachaPolyCiphers.CHACHA_POLY_OPENSSH(),
@@ -206,27 +198,22 @@ public class DefaultConfig
                 StreamCiphers.Arcfour256())
         );
 
-        boolean warn = false;
-        // Ref. https://issues.apache.org/jira/browse/SSHD-24
-        // "AES256 and AES192 requires unlimited cryptography extension"
-        for (Iterator<Factory.Named<Cipher>> i = avail.iterator(); i.hasNext(); ) {
-            final Factory.Named<Cipher> f = i.next();
+        final ListIterator<Factory.Named<Cipher>> factories = avail.listIterator();
+        while (factories.hasNext()) {
+            final Factory.Named<Cipher> factory = factories.next();
             try {
-                final Cipher c = f.create();
-                final byte[] key = new byte[c.getBlockSize()];
-                final byte[] iv = new byte[c.getIVSize()];
-                c.init(Cipher.Mode.Encrypt, key, iv);
+                final Cipher cipher = factory.create();
+                final byte[] key = new byte[cipher.getBlockSize()];
+                final byte[] iv = new byte[cipher.getIVSize()];
+                cipher.init(Cipher.Mode.Encrypt, key, iv);
             } catch (Exception e) {
-                warn = true;
-                log.warn(e.getCause().getMessage());
-                i.remove();
+                log.info("Cipher [{}] disabled: {}", factory.getName(), e.getCause().getMessage());
+                factories.remove();
             }
         }
-        if (warn)
-            log.warn("Disabling high-strength ciphers: cipher strengths apparently limited by JCE policy");
 
         setCipherFactories(avail);
-        log.debug("Available cipher factories: {}", avail);
+        log.debug("Available Ciphers {}", avail);
     }
 
     protected void initMACFactories() {

src/main/java/net/schmizz/sshj/DefaultSecurityProviderConfig.java

@@ -13,22 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.hierynomus.sshj.signature
+package net.schmizz.sshj;
 
-import com.hierynomus.sshj.IntegrationBaseSpec
-import net.schmizz.sshj.DefaultConfig
-import spock.lang.Unroll
+import net.schmizz.sshj.common.SecurityUtils;
 
-class RsaSignatureClientKeySpec extends IntegrationBaseSpec {
-    @Unroll
-    def "should correctly connect using publickey auth with RSA key with signature"() {
-        given:
-        def client = getConnectedClient(new DefaultConfig())
-
-        when:
-        client.authPublickey(USERNAME, "src/itest/resources/keyfiles/id_rsa2")
-
-        then:
-        client.authenticated
+/**
+ * SSHJ Configuration that uses the default Security Provider configuration from java.security and disables Bouncy Castle registration
+ */
+public class DefaultSecurityProviderConfig extends DefaultConfig {
+    static {
+        // Disable Bouncy Castle Provider registration prior to invoking constructors
+        SecurityUtils.setRegisterBouncyCastle(false);
     }
 }

src/main/java/net/schmizz/sshj/SSHClient.java

@@ -15,6 +15,8 @@
  */
 package net.schmizz.sshj;
 
+import net.schmizz.keepalive.KeepAlive;
+import com.hierynomus.sshj.common.ThreadNameProvider;
 import net.schmizz.sshj.common.*;
 import net.schmizz.sshj.connection.Connection;
 import net.schmizz.sshj.connection.ConnectionException;
@@ -26,7 +28,6 @@ import net.schmizz.sshj.connection.channel.forwarded.RemotePortForwarder.Forward
 import net.schmizz.sshj.connection.channel.forwarded.X11Forwarder;
 import net.schmizz.sshj.connection.channel.forwarded.X11Forwarder.X11Channel;
 import net.schmizz.sshj.sftp.SFTPClient;
-import net.schmizz.sshj.sftp.SFTPEngine;
 import net.schmizz.sshj.sftp.StatefulSFTPClient;
 import net.schmizz.sshj.transport.Transport;
 import net.schmizz.sshj.transport.TransportException;
@@ -55,6 +56,7 @@ import javax.security.auth.login.LoginContext;
 import java.io.Closeable;
 import java.io.File;
 import java.io.IOException;
+import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 import java.nio.charset.Charset;
 import java.security.KeyPair;
@@ -424,6 +426,7 @@ public class SSHClient
     @Override
     public void disconnect()
             throws IOException {
+        conn.getKeepAlive().interrupt();
         for (LocalPortForwarder forwarder : forwarders) {
             try {
                 forwarder.close();
@@ -441,6 +444,16 @@ public class SSHClient
         return conn;
     }
 
+    /**
+     * Get Remote Socket Address from Transport
+     *
+     * @return Remote Socket Address or null when not connected
+     */
+    @Override
+    public InetSocketAddress getRemoteSocketAddress() {
+        return trans.getRemoteSocketAddress();
+    }
+
     /**
      * Returns the character set used to communicate with the remote machine for certain strings (like paths).
      *
@@ -537,7 +550,7 @@ public class SSHClient
      * Creates a {@link KeyProvider} instance from given location on the file system. Currently the following private key files are supported:
      * <ul>
      *     <li>PKCS8 (OpenSSH uses this format)</li>
-     *     <li>PKCS5</li>
+     *     <li>PEM-encoded PKCS1</li>
      *     <li>Putty keyfile</li>
      *     <li>openssh-key-v1 (New OpenSSH keyfile format)</li>
      * </ul>
@@ -719,7 +732,7 @@ public class SSHClient
             throws IOException {
         checkConnected();
         checkAuthenticated();
-        return new SFTPClient(new SFTPEngine(this).init());
+        return new SFTPClient(this);
     }
 
     /**
@@ -728,11 +741,11 @@ public class SSHClient
      *
      * @throws IOException if there is an error starting the {@code sftp} subsystem
      */
-    public SFTPClient newStatefulSFTPClient()
+    public StatefulSFTPClient newStatefulSFTPClient()
             throws IOException {
         checkConnected();
         checkAuthenticated();
-        return new StatefulSFTPClient(new SFTPEngine(this).init());
+        return new StatefulSFTPClient(this);
     }
 
     /**
@@ -791,6 +804,11 @@ public class SSHClient
             throws IOException {
         super.onConnect();
         trans.init(getRemoteHostname(), getRemotePort(), getInputStream(), getOutputStream());
+        final KeepAlive keepAliveThread = conn.getKeepAlive();
+        if (keepAliveThread.isEnabled()) {
+            ThreadNameProvider.setThreadName(conn.getKeepAlive(), trans);
+            keepAliveThread.start();
+        }
         doKex();
     }
 

src/main/java/net/schmizz/sshj/SocketClient.java

@@ -15,8 +15,6 @@
  */
 package net.schmizz.sshj;
 
-import com.hierynomus.sshj.backport.JavaVersion;
-import com.hierynomus.sshj.backport.Jdk7HttpProxySocket;
 import net.schmizz.sshj.connection.channel.Channel;
 import net.schmizz.sshj.connection.channel.direct.DirectConnection;
 
@@ -26,7 +24,6 @@ import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
-import java.net.Proxy;
 import java.net.Socket;
 
 public abstract class SocketClient {
@@ -57,73 +54,6 @@ public abstract class SocketClient {
         return new InetSocketAddress(hostname, port);
     }
 
-    /**
-     * Connect to a host via a proxy.
-     * @param hostname The host name to connect to.
-     * @param proxy The proxy to connect via.
-     * @deprecated This method will be removed after v0.12.0. If you want to connect via a proxy, you can do this by injecting a {@link javax.net.SocketFactory}
-     *             into the SocketClient. The SocketFactory should create sockets using the {@link java.net.Socket#Socket(java.net.Proxy)} constructor.
-     */
-    @Deprecated
-    public void connect(String hostname, Proxy proxy) throws IOException {
-        connect(hostname, defaultPort, proxy);
-    }
-
-    /**
-     * Connect to a host via a proxy.
-     * @param hostname The host name to connect to.
-     * @param port The port to connect to.
-     * @param proxy The proxy to connect via.
-     * @deprecated This method will be removed after v0.12.0. If you want to connect via a proxy, you can do this by injecting a {@link javax.net.SocketFactory}
-     *             into the SocketClient. The SocketFactory should create sockets using the {@link java.net.Socket#Socket(java.net.Proxy)} constructor.
-     */
-    @Deprecated
-    public void connect(String hostname, int port, Proxy proxy) throws IOException {
-        this.hostname = hostname;
-        this.port = port;
-        if (JavaVersion.isJava7OrEarlier() && proxy.type() == Proxy.Type.HTTP) {
-            // Java7 and earlier have no support for HTTP Connect proxies, return our custom socket.
-            socket = new Jdk7HttpProxySocket(proxy);
-        } else {
-            socket = new Socket(proxy);
-        }
-        socket.connect(makeInetSocketAddress(hostname, port), connectTimeout);
-        onConnect();
-    }
-
-    /**
-     * Connect to a host via a proxy.
-     * @param host The host address to connect to.
-     * @param proxy The proxy to connect via.
-     * @deprecated This method will be removed after v0.12.0. If you want to connect via a proxy, you can do this by injecting a {@link javax.net.SocketFactory}
-     *             into the SocketClient. The SocketFactory should create sockets using the {@link java.net.Socket#Socket(java.net.Proxy)} constructor.
-     */
-    @Deprecated
-    public void connect(InetAddress host, Proxy proxy) throws IOException {
-        connect(host, defaultPort, proxy);
-    }
-
-    /**
-     * Connect to a host via a proxy.
-     * @param host The host address to connect to.
-     * @param port The port to connect to.
-     * @param proxy The proxy to connect via.
-     * @deprecated This method will be removed after v0.12.0. If you want to connect via a proxy, you can do this by injecting a {@link javax.net.SocketFactory}
-     *             into the SocketClient. The SocketFactory should create sockets using the {@link java.net.Socket#Socket(java.net.Proxy)} constructor.
-     */
-    @Deprecated
-    public void connect(InetAddress host, int port, Proxy proxy) throws IOException {
-        this.port = port;
-        if (JavaVersion.isJava7OrEarlier() && proxy.type() == Proxy.Type.HTTP) {
-            // Java7 and earlier have no support for HTTP Connect proxies, return our custom socket.
-            socket = new Jdk7HttpProxySocket(proxy);
-        } else {
-            socket = new Socket(proxy);
-        }
-        socket.connect(new InetSocketAddress(host, port), connectTimeout);
-        onConnect();
-    }
-
     public void connect(String hostname) throws IOException {
         connect(hostname, defaultPort);
     }

src/main/java/net/schmizz/sshj/common/CircularBuffer.java

@@ -0,0 +1,194 @@
+/*
+ * Copyright (C)2009 - SSHJ Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.schmizz.sshj.common;
+
+public class CircularBuffer<T extends CircularBuffer<T>> {
+
+    public static class CircularBufferException
+            extends SSHException {
+
+        public CircularBufferException(String message) {
+            super(message);
+        }
+    }
+
+    public static final class PlainCircularBuffer
+            extends CircularBuffer<PlainCircularBuffer> {
+
+        public PlainCircularBuffer(int size, int maxSize) {
+            super(size, maxSize);
+        }
+    }
+
+    /**
+     * Maximum size of the internal array (one plus the maximum capacity of the buffer).
+     */
+    private final int maxSize;
+    /**
+     * Internal array for the data. All bytes minus one can be used to avoid empty vs full ambiguity when rpos == wpos.
+     */
+    private byte[] data;
+    /**
+     * Next read position. Wraps around the end of the internal array. When it reaches wpos, the buffer becomes empty.
+     * Can take the value data.length, which is equivalent to 0.
+     */
+    private int rpos;
+    /**
+     * Next write position. Wraps around the end of the internal array. If it is equal to rpos, then the buffer is
+     * empty; the code does not allow wpos to reach rpos from the left. This implies that the buffer can store up to
+     * data.length - 1 bytes. Can take the value data.length, which is equivalent to 0.
+     */
+    private int wpos;
+
+    /**
+     * Determines the size to which to grow the internal array.
+     */
+    private int getNextSize(int currentSize) {
+        // Use next power of 2.
+        int nextSize = 1;
+        while (nextSize < currentSize) {
+            nextSize <<= 1;
+            if (nextSize <= 0) {
+                return maxSize;
+            }
+        }
+        return Math.min(nextSize, maxSize); // limit to max size
+    }
+
+    /**
+     * Creates a new circular buffer of the given size. The capacity of the buffer is one less than the size/
+     */
+    public CircularBuffer(int size, int maxSize) {
+        this.maxSize = maxSize;
+        if (size > maxSize) {
+            throw new IllegalArgumentException(
+                String.format("Initial requested size %d larger than maximum size %d", size, maxSize));
+        }
+        int initialSize = getNextSize(size);
+        this.data = new byte[initialSize];
+        this.rpos = 0;
+        this.wpos = 0;
+    }
+
+    /**
+     * Data available in the buffer for reading.
+     */
+    public int available() {
+        int available = wpos - rpos;
+        return available >= 0 ? available : available + data.length; // adjust if wpos is left of rpos
+    }
+
+    private void ensureAvailable(int a)
+            throws CircularBufferException {
+        if (available() < a) {
+            throw new CircularBufferException("Underflow");
+        }
+    }
+
+    /**
+     * Returns how many more bytes this buffer can receive.
+     */
+    public int maxPossibleRemainingCapacity() {
+        // Remaining capacity is one less than remaining space to ensure that wpos does not reach rpos from the left.
+        int remaining = rpos - wpos - 1;
+        if (remaining < 0) {
+            remaining += data.length; // adjust if rpos is left of wpos
+        }
+        // Add the maximum amount the internal array can grow.
+        return remaining + maxSize - data.length;
+    }
+
+    /**
+     * If the internal array does not have room for "capacity" more bytes, resizes the array to make that room.
+     */
+    void ensureCapacity(int capacity) throws CircularBufferException {
+        int available = available();
+        int remaining = data.length - available;
+        // If capacity fits exactly in the remaining space, expand it; otherwise, wpos would reach rpos from the left.
+        if (remaining <= capacity) {
+            int neededSize = available + capacity + 1;
+            int nextSize = getNextSize(neededSize);
+            if (nextSize < neededSize) {
+                throw new CircularBufferException("Attempted overflow");
+            }
+            byte[] tmp = new byte[nextSize];
+            // Copy data to the beginning of the new array.
+            if (wpos >= rpos) {
+                System.arraycopy(data, rpos, tmp, 0, available);
+                wpos -= rpos; // wpos must be relative to the new rpos, which will be 0
+            } else {
+                int tail = data.length - rpos;
+                System.arraycopy(data, rpos, tmp, 0, tail); // segment right of rpos
+                System.arraycopy(data, 0, tmp, tail, wpos); // segment left of wpos
+                wpos += tail; // wpos must be relative to the new rpos, which will be 0
+            }
+            rpos = 0;
+            data = tmp;
+        }
+    }
+
+    /**
+     * Reads data from this buffer into the provided array.
+     */
+    public void readRawBytes(byte[] destination, int offset, int length) throws CircularBufferException {
+        ensureAvailable(length);
+
+        int rposNext = rpos + length;
+        if (rposNext <= data.length) {
+            System.arraycopy(data, rpos, destination, offset, length);
+        } else {
+            int tail = data.length - rpos;
+            System.arraycopy(data, rpos, destination, offset, tail); // segment right of rpos
+            rposNext = length - tail; // rpos wraps around the end of the buffer
+            System.arraycopy(data, 0, destination, offset + tail, rposNext); // remainder
+        }
+        // This can make rpos equal data.length, which has the same effect as wpos being 0.
+        rpos = rposNext;
+    }
+
+    /**
+     * Writes data to this buffer from the provided array.
+     */
+    @SuppressWarnings("unchecked")
+    public T putRawBytes(byte[] source, int offset, int length) throws CircularBufferException {
+        ensureCapacity(length);
+
+        int wposNext = wpos + length;
+        if (wposNext <= data.length) {
+            System.arraycopy(source, offset, data, wpos, length);
+        } else {
+            int tail = data.length - wpos;
+            System.arraycopy(source, offset, data, wpos, tail); // segment right of wpos
+            wposNext = length - tail; // wpos wraps around the end of the buffer
+            System.arraycopy(source, offset + tail, data, 0, wposNext); // remainder
+        }
+        // This can make wpos equal data.length, which has the same effect as wpos being 0.
+        wpos = wposNext;
+
+        return (T) this;
+    }
+
+    // Used only for testing.
+    int length() {
+        return data.length;
+    }
+
+    @Override
+    public String toString() {
+        return "CircularBuffer [rpos=" + rpos + ", wpos=" + wpos + ", size=" + data.length + "]";
+    }
+
+}

src/main/java/net/schmizz/sshj/common/ECDSAVariationsAdapter.java

@@ -57,9 +57,6 @@ class ECDSAVariationsAdapter {
 
     static PublicKey readPubKeyFromBuffer(Buffer<?> buf, String variation) throws GeneralSecurityException {
         String algorithm = BASE_ALGORITHM_NAME + variation;
-        if (!SecurityUtils.isBouncyCastleRegistered()) {
-            throw new GeneralSecurityException("BouncyCastle is required to read a key of type " + algorithm);
-        }
         try {
             // final String algo = buf.readString(); it has been already read
             final String curveName = buf.readString();

src/main/java/net/schmizz/sshj/common/SecurityUtils.java

@@ -259,6 +259,11 @@ public class SecurityUtils {
         return false;
     }
 
+    /**
+     * Configure whether to register the Bouncy Castle Security Provider. Must be called prior to other methods
+     *
+     * @param registerBouncyCastle Enable or disable Bouncy Castle Provider registration on subsequent method invocation
+     */
     public static synchronized void setRegisterBouncyCastle(boolean registerBouncyCastle) {
         SecurityUtils.registerBouncyCastle = registerBouncyCastle;
         registrationDone = false;

src/main/java/net/schmizz/sshj/common/StreamCopier.java

@@ -145,8 +145,14 @@ public class StreamCopier {
         final double sizeKiB = count / 1024.0;
         log.debug(String.format("%1$,.1f KiB transferred in %2$,.1f seconds (%3$,.2f KiB/s)", sizeKiB, timeSeconds, (sizeKiB / timeSeconds)));
 
-        if (length != -1 && read == -1)
-            throw new IOException("Encountered EOF, could not transfer " + length + " bytes");
+        // Did we encounter EOF?
+        if (read == -1) {
+            // If InputStream was closed we should also close OutputStream
+            out.close();
+
+            if (length != -1)
+                throw new IOException("Encountered EOF, could not transfer " + length + " bytes");
+        }
 
         return count;
     }

src/main/java/net/schmizz/sshj/connection/channel/AbstractChannel.java

@@ -164,8 +164,7 @@ public abstract class AbstractChannel
     }
 
     @Override
-    public void handle(Message msg, SSHPacket buf)
-            throws ConnectionException, TransportException {
+    public void handle(Message msg, SSHPacket buf) throws SSHException {
         switch (msg) {
 
             case CHANNEL_DATA:
@@ -304,6 +303,25 @@ public abstract class AbstractChannel
         }
     }
 
+    // Prevent CHANNEL_CLOSE to be sent between isOpen and a Transport.write call in the runnable, otherwise
+    // a disconnect with a "packet referred to nonexistent channel" message can occur.
+    //
+    // This particularly happens when the transport.Reader thread passes an eof from the server to the
+    // ChannelInputStream, the reading library-user thread returns, and closes the channel at the same time as the
+    // transport.Reader thread receives the subsequent CHANNEL_CLOSE from the server.
+    boolean whileOpen(TransportRunnable runnable) throws TransportException, ConnectionException {
+        openCloseLock.lock();
+        try {
+            if (isOpen()) {
+                runnable.run();
+                return true;
+            }
+        } finally {
+            openCloseLock.unlock();
+        }
+        return false;
+    }
+
     private void gotChannelRequest(SSHPacket buf)
             throws ConnectionException, TransportException {
         final String reqType;
@@ -335,7 +353,7 @@ public abstract class AbstractChannel
     }
 
     protected void gotExtendedData(SSHPacket buf)
-            throws ConnectionException, TransportException {
+            throws SSHException {
         throw new ConnectionException(DisconnectReason.PROTOCOL_ERROR,
                                       "Extended data not supported on " + type + " channel");
     }
@@ -356,7 +374,7 @@ public abstract class AbstractChannel
     }
 
     protected void receiveInto(ChannelInputStream stream, SSHPacket buf)
-            throws ConnectionException, TransportException {
+            throws SSHException {
         final int len;
         try {
             len = buf.readUInt32AsInt();
@@ -427,5 +445,8 @@ public abstract class AbstractChannel
                 + rwin + " >";
     }
 
+    public interface TransportRunnable {
+        void run() throws TransportException, ConnectionException;
+    }
 
 }

src/main/java/net/schmizz/sshj/connection/channel/ChannelInputStream.java

@@ -38,7 +38,7 @@ public final class ChannelInputStream
     private final Channel chan;
     private final Transport trans;
     private final Window.Local win;
-    private final Buffer.PlainBuffer buf;
+    private final CircularBuffer.PlainCircularBuffer buf;
     private final byte[] b = new byte[1];
 
     private boolean eof;
@@ -46,10 +46,11 @@ public final class ChannelInputStream
 
     public ChannelInputStream(Channel chan, Transport trans, Window.Local win) {
         this.chan = chan;
-        log = chan.getLoggerFactory().getLogger(getClass());
+        this.log = chan.getLoggerFactory().getLogger(getClass());
         this.trans = trans;
         this.win = win;
-        buf = new Buffer.PlainBuffer(chan.getLocalMaxPacketSize());
+        this.buf = new CircularBuffer.PlainCircularBuffer(
+            chan.getLocalMaxPacketSize(), trans.getConfig().getMaxCircularBufferSize());
     }
 
     @Override
@@ -105,6 +106,7 @@ public final class ChannelInputStream
                 try {
                     buf.wait();
                 } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
                     throw (IOException) new InterruptedIOException().initCause(e);
                 }
             }
@@ -112,48 +114,44 @@ public final class ChannelInputStream
                 len = buf.available();
             }
             buf.readRawBytes(b, off, len);
-            if (buf.rpos() > win.getMaxPacketSize() && buf.available() == 0) {
-                buf.clear();
-            }
-        }
 
-        if (!chan.getAutoExpand()) {
-            checkWindow();
+            if (!chan.getAutoExpand()) {
+                checkWindow();
+            }
         }
 
         return len;
     }
 
-    public void receive(byte[] data, int offset, int len)
-            throws ConnectionException, TransportException {
+    public void receive(byte[] data, int offset, int len) throws SSHException {
         if (eof) {
             throw new ConnectionException("Getting data on EOF'ed stream");
         }
         synchronized (buf) {
             buf.putRawBytes(data, offset, len);
             buf.notifyAll();
-        }
-        // Potential fix for #203 (window consumed below 0).
-        // This seems to be a race condition if we receive more data, while we're already sending a SSH_MSG_CHANNEL_WINDOW_ADJUST
-        // And the window has not expanded yet.
-        synchronized (win) {
+            // Potential fix for #203 (window consumed below 0).
+            // This seems to be a race condition if we receive more data, while we're already sending a SSH_MSG_CHANNEL_WINDOW_ADJUST
+            // And the window has not expanded yet.
             win.consume(len);
-        }
-        if (chan.getAutoExpand()) {
-            checkWindow();
+            if (chan.getAutoExpand()) {
+                checkWindow();
+            }
         }
     }
 
-    private void checkWindow()
-            throws TransportException {
-        synchronized (win) {
-            final long adjustment = win.neededAdjustment();
-            if (adjustment > 0) {
-                log.debug("Sending SSH_MSG_CHANNEL_WINDOW_ADJUST to #{} for {} bytes", chan.getRecipient(), adjustment);
-                trans.write(new SSHPacket(Message.CHANNEL_WINDOW_ADJUST)
-                        .putUInt32FromInt(chan.getRecipient()).putUInt32(adjustment));
-                win.expand(adjustment);
-            }
+    private void checkWindow() throws TransportException {
+        /*
+         * Window must fit in remaining buffer capacity. We already expect win.size() amount of data to arrive. The
+         * difference between that and the remaining capacity is the maximum adjustment we can make to the window.
+         */
+        final long maxAdjustment = buf.maxPossibleRemainingCapacity() - win.getSize();
+        final long adjustment = Math.min(win.neededAdjustment(), maxAdjustment);
+        if (adjustment > 0) {
+            log.debug("Sending SSH_MSG_CHANNEL_WINDOW_ADJUST to #{} for {} bytes", chan.getRecipient(), adjustment);
+            trans.write(new SSHPacket(Message.CHANNEL_WINDOW_ADJUST)
+                    .putUInt32FromInt(chan.getRecipient()).putUInt32(adjustment));
+            win.expand(adjustment);
         }
     }
 

src/main/java/net/schmizz/sshj/connection/channel/ChannelOutputStream.java

@@ -30,7 +30,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
  */
 public final class ChannelOutputStream extends OutputStream implements ErrorNotifiable {
 
-    private final Channel chan;
+    private final AbstractChannel chan;
     private final Transport trans;
     private final Window.Remote win;
 
@@ -47,6 +47,12 @@ public final class ChannelOutputStream extends OutputStream implements ErrorNoti
 
         private final SSHPacket packet = new SSHPacket(Message.CHANNEL_DATA);
         private final Buffer.PlainBuffer leftOvers = new Buffer.PlainBuffer();
+        private final AbstractChannel.TransportRunnable packetWriteRunnable = new AbstractChannel.TransportRunnable() {
+            @Override
+            public void run() throws TransportException {
+                trans.write(packet);
+            }
+        };
 
         DataBuffer() {
             headerOffset = packet.rpos();
@@ -99,8 +105,9 @@ public final class ChannelOutputStream extends OutputStream implements ErrorNoti
                 if (leftOverBytes > 0) {
                     leftOvers.putRawBytes(packet.array(), packet.wpos(), leftOverBytes);
                 }
-
-                trans.write(packet);
+                if (!chan.whileOpen(packetWriteRunnable)) {
+                    throwStreamClosed();
+                }
                 win.consume(writeNow);
 
                 packet.rpos(headerOffset);
@@ -119,7 +126,7 @@ public final class ChannelOutputStream extends OutputStream implements ErrorNoti
 
     }
 
-    public ChannelOutputStream(Channel chan, Transport trans, Window.Remote win) {
+    public ChannelOutputStream(AbstractChannel chan, Transport trans, Window.Remote win) {
         this.chan = chan;
         this.trans = trans;
         this.win = win;
@@ -157,7 +164,7 @@ public final class ChannelOutputStream extends OutputStream implements ErrorNoti
             if (error != null) {
                 throw error;
             } else {
-                throw new ConnectionException("Stream closed");
+                throwStreamClosed();
             }
         }
     }
@@ -165,9 +172,14 @@ public final class ChannelOutputStream extends OutputStream implements ErrorNoti
     @Override
     public synchronized void close() throws IOException {
         // Not closed yet, and underlying channel is open to flush the data to.
-        if (!closed.getAndSet(true) && chan.isOpen()) {
-            buffer.flush(false);
-            trans.write(new SSHPacket(Message.CHANNEL_EOF).putUInt32(chan.getRecipient()));
+        if (!closed.getAndSet(true)) {
+            chan.whileOpen(new AbstractChannel.TransportRunnable() {
+                @Override
+                public void run() throws TransportException, ConnectionException {
+                    buffer.flush(false);
+                    trans.write(new SSHPacket(Message.CHANNEL_EOF).putUInt32(chan.getRecipient()));
+                }
+            });
         }
     }
 
@@ -188,4 +200,7 @@ public final class ChannelOutputStream extends OutputStream implements ErrorNoti
         return "< ChannelOutputStream for Channel #" + chan.getID() + " >";
     }
 
+    private static void throwStreamClosed() throws ConnectionException {
+        throw new ConnectionException("Stream closed");
+    }
 }

src/main/java/net/schmizz/sshj/connection/channel/SocketStreamCopyMonitor.java

@@ -22,8 +22,6 @@ import java.io.IOException;
 import java.net.Socket;
 import java.util.concurrent.TimeUnit;
 
-import static com.hierynomus.sshj.backport.Sockets.asCloseable;
-
 public class SocketStreamCopyMonitor
         extends Thread {
 
@@ -43,7 +41,7 @@ public class SocketStreamCopyMonitor
                     await(y);
                 } catch (IOException ignored) {
                 } finally {
-                    IOUtils.closeQuietly(channel, asCloseable(socket));
+                    IOUtils.closeQuietly(channel, socket);
                 }
             }
 

src/main/java/net/schmizz/sshj/connection/channel/Window.java

@@ -93,6 +93,7 @@ public abstract class Window {
                             throw new ConnectionException("Timeout when trying to expand the window size");
                         }
                     } catch (InterruptedException ie) {
+                        Thread.currentThread().interrupt();
                         throw new ConnectionException(ie);
                     }
                 }

src/main/java/net/schmizz/sshj/connection/channel/direct/LocalPortForwarder.java

@@ -29,8 +29,6 @@ import java.net.Socket;
 import java.net.SocketException;
 import java.util.concurrent.TimeUnit;
 
-import static com.hierynomus.sshj.backport.Sockets.asCloseable;
-
 public class LocalPortForwarder {
 
     public static class ForwardedChannel
@@ -78,7 +76,7 @@ public class LocalPortForwarder {
             chan.open();
             chan.start();
         } catch (IOException e) {
-            IOUtils.closeQuietly(chan, asCloseable(socket));
+            IOUtils.closeQuietly(chan, socket);
             throw e;
         }
     }

src/main/java/net/schmizz/sshj/connection/channel/direct/SessionChannel.java

@@ -210,7 +210,7 @@ public class SessionChannel
 
     @Override
     protected void gotExtendedData(SSHPacket buf)
-            throws ConnectionException, TransportException {
+            throws SSHException {
         try {
             final int dataTypeCode = buf.readUInt32AsInt();
             if (dataTypeCode == 1)

src/main/java/net/schmizz/sshj/connection/channel/direct/SessionFactory.java

@@ -15,10 +15,11 @@
  */
 package net.schmizz.sshj.connection.channel.direct;
 
+import com.hierynomus.sshj.common.RemoteAddressProvider;
 import net.schmizz.sshj.common.SSHException;
 
 /** A factory interface for creating SSH {@link Session session channels}. */
-public interface SessionFactory {
+public interface SessionFactory extends RemoteAddressProvider {
 
     /**
      * Opens a {@code session} channel. The returned {@link Session} instance allows {@link Session#exec(String)
@@ -27,7 +28,7 @@ public interface SessionFactory {
      *
      * @return the opened {@code session} channel
      *
-     * @throws SSHException
+     * @throws SSHException Thrown on session initialization failures
      * @see Session
      */
     Session startSession()

src/main/java/net/schmizz/sshj/connection/channel/forwarded/RemotePortForwarder.java

@@ -142,6 +142,10 @@ public class RemotePortForwarder
                 // Listen on all IPv4
                 return true;
             }
+            if ("0.0.0.0".equals(address) && "0:0:0:0:0:0:0:0".equals(channelForward.address)) {
+                // Handle IPv4 requests on IPv6 channel forward
+                return true;
+            }
             return false;
         }
 

src/main/java/net/schmizz/sshj/sftp/PacketReader.java

@@ -41,7 +41,7 @@ public class PacketReader extends Thread {
         this.engine = engine;
         log = engine.getLoggerFactory().getLogger(getClass());
         this.in = engine.getSubsystem().getInputStream();
-        setName("sftp reader");
+        setName("sshj-PacketReader");
         setDaemon(true);
     }
 

src/main/java/net/schmizz/sshj/sftp/RemoteFile.java

@@ -23,6 +23,8 @@ import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.util.ArrayDeque;
+import java.util.Deque;
 import java.util.LinkedList;
 import java.util.Queue;
 import java.util.concurrent.TimeUnit;
@@ -220,49 +222,104 @@ public class RemoteFile
 
     public class ReadAheadRemoteFileInputStream
             extends InputStream {
+        private class UnconfirmedRead {
+            private final long offset;
+            private final Promise<Response, SFTPException> promise;
+            private final int length;
+
+            private UnconfirmedRead(long offset, int length, Promise<Response, SFTPException> promise) {
+                this.offset = offset;
+                this.length = length;
+                this.promise = promise;
+            }
+
+            UnconfirmedRead(long offset, int length) throws IOException {
+                this(offset, length, RemoteFile.this.asyncRead(offset, length));
+            }
+
+            public long getOffset() {
+                return offset;
+            }
+
+            public Promise<Response, SFTPException> getPromise() {
+                return promise;
+            }
+
+            public int getLength() {
+                return length;
+            }
+        }
 
         private final byte[] b = new byte[1];
 
         private final int maxUnconfirmedReads;
-        private final Queue<Promise<Response, SFTPException>> unconfirmedReads = new LinkedList<Promise<Response, SFTPException>>();
-        private final Queue<Long> unconfirmedReadOffsets = new LinkedList<Long>();
+        private final long readAheadLimit;
+        private final Deque<UnconfirmedRead> unconfirmedReads = new ArrayDeque<>();
 
-        private long requestOffset;
-        private long responseOffset;
+        private long currentOffset;
+        private int maxReadLength = Integer.MAX_VALUE;
         private boolean eof;
 
         public ReadAheadRemoteFileInputStream(int maxUnconfirmedReads) {
-            assert 0 <= maxUnconfirmedReads;
-
-            this.maxUnconfirmedReads = maxUnconfirmedReads;
+            this(maxUnconfirmedReads, 0L);
+        }
+        
+        /**
+         *
+         * @param maxUnconfirmedReads Maximum number of unconfirmed requests to send
+         * @param fileOffset Initial offset in file to read from
+         */
+        public ReadAheadRemoteFileInputStream(int maxUnconfirmedReads, long fileOffset) {
+            this(maxUnconfirmedReads, fileOffset, -1L);
         }
 
-        public ReadAheadRemoteFileInputStream(int maxUnconfirmedReads, long fileOffset) {
+        /**
+         *
+         * @param maxUnconfirmedReads Maximum number of unconfirmed requests to send
+         * @param fileOffset Initial offset in file to read from
+         * @param readAheadLimit Read ahead is disabled after this limit has been reached
+         */
+        public ReadAheadRemoteFileInputStream(int maxUnconfirmedReads, long fileOffset, long readAheadLimit) {
             assert 0 <= maxUnconfirmedReads;
             assert 0 <= fileOffset;
 
             this.maxUnconfirmedReads = maxUnconfirmedReads;
-            this.requestOffset = this.responseOffset = fileOffset;
+            this.currentOffset = fileOffset;
+            this.readAheadLimit = readAheadLimit > 0 ? fileOffset + readAheadLimit : Long.MAX_VALUE;
         }
 
         private ByteArrayInputStream pending = new ByteArrayInputStream(new byte[0]);
 
         private boolean retrieveUnconfirmedRead(boolean blocking) throws IOException {
-            if (unconfirmedReads.size() <= 0) {
+            final UnconfirmedRead unconfirmedRead = unconfirmedReads.peek();
+            if (unconfirmedRead == null || !blocking && !unconfirmedRead.getPromise().isDelivered()) {
                 return false;
             }
+            unconfirmedReads.remove(unconfirmedRead);
 
-            if (!blocking && !unconfirmedReads.peek().isDelivered()) {
-                return false;
-            }
-
-            unconfirmedReadOffsets.remove();
-            final Response res = unconfirmedReads.remove().retrieve(requester.getTimeoutMs(), TimeUnit.MILLISECONDS);
+            final Response res = unconfirmedRead.promise.retrieve(requester.getTimeoutMs(), TimeUnit.MILLISECONDS);
             switch (res.getType()) {
                 case DATA:
                     int recvLen = res.readUInt32AsInt();
-                    responseOffset += recvLen;
-                    pending = new ByteArrayInputStream(res.array(), res.rpos(), recvLen);
+                    if (unconfirmedRead.offset == currentOffset) {
+                        currentOffset += recvLen;
+                        pending = new ByteArrayInputStream(res.array(), res.rpos(), recvLen);
+
+                        if (recvLen < unconfirmedRead.length) {
+                            // The server returned a packet smaller than the client had requested.
+                            // It can be caused by at least one of the following:
+                            // * The file has been read fully. Then, few futile read requests can be sent during
+                            //   the next read(), but the file will be downloaded correctly anyway.
+                            // * The server shapes the request length. Then, the read window will be adjusted,
+                            //   and all further read-ahead requests won't be shaped.
+                            // * The file on the server is not a regular file, it is something like fifo.
+                            //   Then, the window will shrink, and the client will start reading the file slower than it
+                            //   hypothetically can. It must be a rare case, and it is not worth implementing a sort of
+                            //   congestion control algorithm here.
+                            maxReadLength = recvLen;
+                            unconfirmedReads.clear();
+                        }
+                    }
                     break;
 
                 case STATUS:
@@ -290,40 +347,31 @@ public class RemoteFile
                 // we also need to go here for len <= 0, because pending may be at
                 // EOF in which case it would return -1 instead of 0
 
+                long requestOffset;
+                if (unconfirmedReads.isEmpty()) {
+                    requestOffset = currentOffset;
+                }
+                else {
+                    final UnconfirmedRead lastRequest = unconfirmedReads.getLast();
+                    requestOffset = lastRequest.offset + lastRequest.length;
+                }
                 while (unconfirmedReads.size() <= maxUnconfirmedReads) {
                     // Send read requests as long as there is no EOF and we have not reached the maximum parallelism
-                    int reqLen = Math.max(1024, len); // don't be shy!
-                    unconfirmedReads.add(RemoteFile.this.asyncRead(requestOffset, reqLen));
-                    unconfirmedReadOffsets.add(requestOffset);
+                    int reqLen = Math.min(Math.max(1024, len), maxReadLength);
+                    if (readAheadLimit > requestOffset) {
+                        long remaining = readAheadLimit - requestOffset;
+                        if (reqLen > remaining) {
+                            reqLen = (int) remaining;
+                        }
+                    }
+                    unconfirmedReads.add(new UnconfirmedRead(requestOffset, reqLen));
                     requestOffset += reqLen;
+                    if (requestOffset >= readAheadLimit) {
+                        break;
+                    }
                 }
 
-                long nextOffset = unconfirmedReadOffsets.peek();
-                if (responseOffset != nextOffset) {
-
-                    // the server could not give us all the data we needed, so
-                    // we try to fill the gap synchronously
-
-                    assert responseOffset < nextOffset;
-                    assert 0 < (nextOffset - responseOffset);
-                    assert (nextOffset - responseOffset) <= Integer.MAX_VALUE;
-
-                    byte[] buf = new byte[(int) (nextOffset - responseOffset)];
-                    int recvLen = RemoteFile.this.read(responseOffset, buf, 0, buf.length);
-
-                    if (recvLen < 0) {
-                        eof = true;
-                        return -1;
-                    }
-
-                    if (0 == recvLen) {
-                        // avoid infinite loops
-                        throw new SFTPException("Unexpected response size (0), bailing out");
-                    }
-
-                    responseOffset += recvLen;
-                    pending = new ByteArrayInputStream(buf, 0, recvLen);
-                } else if (!retrieveUnconfirmedRead(true /*blocking*/)) {
+                if (!retrieveUnconfirmedRead(true /*blocking*/)) {
 
                     // this may happen if we change prefetch strategy
                     // currently, we should never get here...

src/main/java/net/schmizz/sshj/sftp/SFTPClient.java

@@ -15,6 +15,7 @@
  */
 package net.schmizz.sshj.sftp;
 
+import net.schmizz.sshj.connection.channel.direct.SessionFactory;
 import net.schmizz.sshj.xfer.FilePermission;
 import net.schmizz.sshj.xfer.LocalDestFile;
 import net.schmizz.sshj.xfer.LocalSourceFile;
@@ -39,6 +40,13 @@ public class SFTPClient
         this.xfer = new SFTPFileTransfer(engine);
     }
 
+    public SFTPClient(SessionFactory sessionFactory) throws IOException {
+        this.engine = new SFTPEngine(sessionFactory);
+        this.engine.init();
+        log = engine.getLoggerFactory().getLogger(getClass());
+        this.xfer = new SFTPFileTransfer(engine);
+    }
+
     public SFTPEngine getSFTPEngine() {
         return engine;
     }
@@ -233,21 +241,41 @@ public class SFTPClient
         xfer.download(source, dest);
     }
 
+    public void get(String source, String dest, long byteOffset)
+            throws IOException {
+        xfer.download(source, dest, byteOffset);
+    }
+
     public void put(String source, String dest)
             throws IOException {
         xfer.upload(source, dest);
     }
 
+    public void put(String source, String dest, long byteOffset)
+            throws IOException {
+        xfer.upload(source, dest, byteOffset);
+    }
+
     public void get(String source, LocalDestFile dest)
             throws IOException {
         xfer.download(source, dest);
     }
 
+    public void get(String source, LocalDestFile dest, long byteOffset)
+            throws IOException {
+        xfer.download(source, dest, byteOffset);
+    }
+
     public void put(LocalSourceFile source, String dest)
             throws IOException {
         xfer.upload(source, dest);
     }
 
+    public void put(LocalSourceFile source, String dest, long byteOffset)
+            throws IOException {
+        xfer.upload(source, dest, byteOffset);
+    }
+
     @Override
     public void close()
             throws IOException {

src/main/java/net/schmizz/sshj/sftp/SFTPEngine.java

@@ -15,6 +15,7 @@
  */
 package net.schmizz.sshj.sftp;
 
+import com.hierynomus.sshj.common.ThreadNameProvider;
 import net.schmizz.concurrent.Promise;
 import net.schmizz.sshj.common.IOUtils;
 import net.schmizz.sshj.common.LoggerFactory;
@@ -68,6 +69,7 @@ public class SFTPEngine
         sub = session.startSubsystem("sftp");
         out = sub.getOutputStream();
         reader = new PacketReader(this);
+        ThreadNameProvider.setThreadName(reader, ssh);
         pathHelper = new PathHelper(new PathHelper.Canonicalizer() {
             @Override
             public String canonicalize(String path)
@@ -79,7 +81,23 @@ public class SFTPEngine
 
     public SFTPEngine init()
             throws IOException {
-        transmit(new SFTPPacket<Request>(PacketType.INIT).putUInt32(MAX_SUPPORTED_VERSION));
+        return init(MAX_SUPPORTED_VERSION);
+    }
+
+    /**
+     * Introduced for internal use by testcases.
+     * @param requestedVersion
+     * @throws IOException
+     */
+    protected SFTPEngine init(int requestedVersion)
+            throws IOException {
+        if (requestedVersion > MAX_SUPPORTED_VERSION)
+            throw new SFTPException("You requested an unsupported protocol version: " + requestedVersion + " (requested) > " + MAX_SUPPORTED_VERSION + " (supported)");
+
+        if (requestedVersion < MAX_SUPPORTED_VERSION)
+            log.debug("Client version {} is smaller than MAX_SUPPORTED_VERSION {}", requestedVersion, MAX_SUPPORTED_VERSION);
+
+        transmit(new SFTPPacket<Request>(PacketType.INIT).putUInt32(requestedVersion));
 
         final SFTPPacket<Response> response = reader.readPacket();
 
@@ -89,7 +107,7 @@ public class SFTPEngine
 
         operativeVersion = response.readUInt32AsInt();
         log.debug("Server version {}", operativeVersion);
-        if (MAX_SUPPORTED_VERSION < operativeVersion)
+        if (requestedVersion < operativeVersion)
             throw new SFTPException("Server reported incompatible protocol version: " + operativeVersion);
 
         while (response.available() > 0)
@@ -232,17 +250,79 @@ public class SFTPEngine
 
     public void rename(String oldPath, String newPath, Set<RenameFlags> flags)
             throws IOException {
-        if (operativeVersion < 1)
+        if (operativeVersion < 1) {
             throw new SFTPException("RENAME is not supported in SFTPv" + operativeVersion);
-
-        long renameFlagMask = 0L;
-        for (RenameFlags flag : flags) {
-            renameFlagMask = renameFlagMask | flag.longValue();
         }
 
-        doRequest(
-                newRequest(PacketType.RENAME).putString(oldPath, sub.getRemoteCharset()).putString(newPath, sub.getRemoteCharset()).putUInt32(renameFlagMask)
-        ).ensureStatusPacketIsOK();
+        // request variables to be determined
+        PacketType type = PacketType.RENAME; // Default
+        long renameFlagMask = 0L;
+        String serverExtension = null;
+
+        if (!flags.isEmpty()) {
+            // SFTP Version 5 introduced rename flags according to Section 6.5 of the specification
+            if (operativeVersion >= 5) {
+                for (RenameFlags flag : flags) {
+                    renameFlagMask = renameFlagMask | flag.longValue();
+                }
+            }
+            // Try to find a fallback solution if flags are not supported by the server.
+
+            // "posix-rename@openssh.com" provides ATOMIC and OVERWRITE behaviour.
+            //  From the SFTP-spec, Section 6.5:
+            // "If SSH_FXP_RENAME_OVERWRITE is specified, the server MAY perform an atomic rename even if it is
+            // not requested."
+            // So, if overwrite is allowed we can always use the posix-rename as a fallback.
+            else if (flags.contains(RenameFlags.OVERWRITE) &&
+                    supportsServerExtension("posix-rename","openssh.com")) {
+
+                type = PacketType.EXTENDED;
+                serverExtension = "posix-rename@openssh.com";
+            }
+
+            // Because the OVERWRITE flag changes the behaviour in a possibly unintended way, it has to be
+            // explicitly requested for the above fallback to be applicable.
+            // Tell this to the developer if ATOMIC is requested without OVERWRITE.
+            else if (flags.contains(RenameFlags.ATOMIC) &&
+                    !flags.contains(RenameFlags.OVERWRITE) &&
+                    !flags.contains(RenameFlags.NATIVE) && // see next case below
+                    supportsServerExtension("posix-rename","openssh.com")) {
+                throw new SFTPException("RENAME-FLAGS are not supported in SFTPv" + operativeVersion + " but " +
+                            "the \"posix-rename@openssh.com\" extension could be used as fallback if OVERWRITE " +
+                            "behaviour is acceptable (needs to be activated via RenameFlags.OVERWRITE).");
+            }
+
+            // From the SFTP-spec, Section 6.5:
+            // "If flags includes SSH_FXP_RENAME_NATIVE, the server is free to do the rename operation in whatever
+            // fashion it deems appropriate. Other flag values are considered hints as to desired behavior, but not
+            // requirements."
+            else if (flags.contains(RenameFlags.NATIVE)) {
+                log.debug("Flags are not supported but NATIVE-flag allows to ignore other requested flags: " +
+                        flags.toString());
+            }
+
+            // finally: let the user know that the server does not support what was asked
+            else {
+                throw new SFTPException("RENAME-FLAGS are not supported in SFTPv" + operativeVersion + " and no " +
+                        "supported server extension could be found to achieve a similar result.");
+            }
+        }
+
+        // build and send request
+        final Request request = newRequest(type);
+
+        if (serverExtension != null) {
+            request.putString(serverExtension);
+        }
+
+        request.putString(oldPath, sub.getRemoteCharset())
+                .putString(newPath, sub.getRemoteCharset());
+
+        if (renameFlagMask != 0L) {
+            request.putUInt32(renameFlagMask);
+        }
+
+        doRequest(request).ensureStatusPacketIsOK();
     }
 
     public String canonicalize(String path)

src/main/java/net/schmizz/sshj/sftp/SFTPFileTransfer.java

@@ -50,25 +50,47 @@ public class SFTPFileTransfer
     @Override
     public void upload(String source, String dest)
             throws IOException {
-        upload(new FileSystemFile(source), dest);
+        upload(source, dest, 0);
+    }
+    
+    @Override
+    public void upload(String source, String dest, long byteOffset)
+            throws IOException {
+        upload(new FileSystemFile(source), dest, byteOffset);
     }
 
     @Override
     public void download(String source, String dest)
             throws IOException {
-        download(source, new FileSystemFile(dest));
+        download(source, dest, 0);
+    }
+    
+    @Override
+    public void download(String source, String dest, long byteOffset)
+            throws IOException {
+        download(source, new FileSystemFile(dest), byteOffset);
     }
 
     @Override
     public void upload(LocalSourceFile localFile, String remotePath) throws IOException {
-        new Uploader(localFile, remotePath).upload(getTransferListener());
+        upload(localFile, remotePath, 0);
+    }
+    
+    @Override
+    public void upload(LocalSourceFile localFile, String remotePath, long byteOffset) throws IOException {
+        new Uploader(localFile, remotePath).upload(getTransferListener(), byteOffset);
     }
 
     @Override
     public void download(String source, LocalDestFile dest) throws IOException {
+        download(source, dest, 0);
+    }
+    
+    @Override
+    public void download(String source, LocalDestFile dest, long byteOffset) throws IOException {
         final PathComponents pathComponents = engine.getPathHelper().getComponents(source);
         final FileAttributes attributes = engine.stat(source);
-        new Downloader().download(getTransferListener(), new RemoteResourceInfo(pathComponents, attributes), dest);
+        new Downloader().download(getTransferListener(), new RemoteResourceInfo(pathComponents, attributes), dest, byteOffset);
     }
 
     public void setUploadFilter(LocalFileFilter uploadFilter) {
@@ -92,7 +114,8 @@ public class SFTPFileTransfer
         @SuppressWarnings("PMD.MissingBreakInSwitch")
         private void download(final TransferListener listener,
                               final RemoteResourceInfo remote,
-                              final LocalDestFile local) throws IOException {
+                              final LocalDestFile local,
+                              final long byteOffset) throws IOException {
             final LocalDestFile adjustedFile;
             switch (remote.getAttributes().getType()) {
                 case DIRECTORY:
@@ -101,8 +124,9 @@ public class SFTPFileTransfer
                 case UNKNOWN:
                     log.warn("Server did not supply information about the type of file at `{}` " +
                                      "-- assuming it is a regular file!", remote.getPath());
+                    // fall through
                 case REGULAR:
-                    adjustedFile = downloadFile(listener.file(remote.getName(), remote.getAttributes().getSize()), remote, local);
+                    adjustedFile = downloadFile(listener.file(remote.getName(), remote.getAttributes().getSize()), remote, local, byteOffset);
                     break;
                 default:
                     throw new IOException(remote + " is not a regular file or directory");
@@ -119,7 +143,7 @@ public class SFTPFileTransfer
             final RemoteDirectory rd = engine.openDir(remote.getPath());
             try {
                 for (RemoteResourceInfo rri : rd.scan(getDownloadFilter()))
-                    download(listener, rri, adjusted.getChild(rri.getName()));
+                    download(listener, rri, adjusted.getChild(rri.getName()), 0); // not supporting individual byte offsets for these files
             } finally {
                 rd.close();
             }
@@ -128,13 +152,15 @@ public class SFTPFileTransfer
 
         private LocalDestFile downloadFile(final StreamCopier.Listener listener,
                                            final RemoteResourceInfo remote,
-                                           final LocalDestFile local)
+                                           final LocalDestFile local,
+                                           final long byteOffset)
                 throws IOException {
             final LocalDestFile adjusted = local.getTargetFile(remote.getName());
             final RemoteFile rf = engine.open(remote.getPath());
             try {
-                final RemoteFile.ReadAheadRemoteFileInputStream rfis = rf.new ReadAheadRemoteFileInputStream(16);
-                final OutputStream os = adjusted.getOutputStream();
+                log.debug("Attempting to download {} with offset={}", remote.getPath(), byteOffset);
+                final RemoteFile.ReadAheadRemoteFileInputStream rfis = rf.new ReadAheadRemoteFileInputStream(16, byteOffset);
+                final OutputStream os = adjusted.getOutputStream(byteOffset != 0);
                 try {
                     new StreamCopier(rfis, os, engine.getLoggerFactory())
                             .bufSize(engine.getSubsystem().getLocalMaxPacketSize())
@@ -173,17 +199,17 @@ public class SFTPFileTransfer
             this.remote = remote;
         }
 
-        private void upload(final TransferListener listener) throws IOException {
+        private void upload(final TransferListener listener, long byteOffset) throws IOException {
             if (source.isDirectory()) {
                 makeDirIfNotExists(remote); // Ensure that the directory exists
                 uploadDir(listener.directory(source.getName()), source, remote);
                 setAttributes(source, remote);
             } else if (source.isFile() && isDirectory(remote)) {
                 String adjustedRemote = engine.getPathHelper().adjustForParent(this.remote, source.getName());
-                uploadFile(listener.file(source.getName(), source.getLength()), source, adjustedRemote);
+                uploadFile(listener.file(source.getName(), source.getLength()), source, adjustedRemote, byteOffset);
                 setAttributes(source, adjustedRemote);
             } else if (source.isFile()) {
-                uploadFile(listener.file(source.getName(), source.getLength()), source, remote);
+                uploadFile(listener.file(source.getName(), source.getLength()), source, remote, byteOffset);
                 setAttributes(source, remote);
             } else {
                 throw new IOException(source + " is not a file or directory");
@@ -192,13 +218,14 @@ public class SFTPFileTransfer
 
         private void upload(final TransferListener listener,
                             final LocalSourceFile local,
-                            final String remote)
+                            final String remote,
+                            final long byteOffset)
                 throws IOException {
             final String adjustedPath;
             if (local.isDirectory()) {
                 adjustedPath = uploadDir(listener.directory(local.getName()), local, remote);
             } else if (local.isFile()) {
-                adjustedPath = uploadFile(listener.file(local.getName(), local.getLength()), local, remote);
+                adjustedPath = uploadFile(listener.file(local.getName(), local.getLength()), local, remote, byteOffset);
             } else {
                 throw new IOException(local + " is not a file or directory");
             }
@@ -217,22 +244,34 @@ public class SFTPFileTransfer
                 throws IOException {
             makeDirIfNotExists(remote);
             for (LocalSourceFile f : local.getChildren(getUploadFilter()))
-                upload(listener, f, engine.getPathHelper().adjustForParent(remote, f.getName()));
+                upload(listener, f, engine.getPathHelper().adjustForParent(remote, f.getName()), 0); // not supporting individual byte offsets for these files
             return remote;
         }
 
         private String uploadFile(final StreamCopier.Listener listener,
                                   final LocalSourceFile local,
-                                  final String remote)
+                                  final String remote,
+                                  final long byteOffset)
                 throws IOException {
-            final String adjusted = prepareFile(local, remote);
+            final String adjusted = prepareFile(local, remote, byteOffset);
             RemoteFile rf = null;
             InputStream fis = null;
             RemoteFile.RemoteFileOutputStream rfos = null;
+            EnumSet<OpenMode> modes;
             try {
-                rf = engine.open(adjusted, EnumSet.of(OpenMode.WRITE, OpenMode.CREAT, OpenMode.TRUNC));
+                if (byteOffset == 0) {
+                    // Starting at the beginning, overwrite/create
+                    modes = EnumSet.of(OpenMode.WRITE, OpenMode.CREAT, OpenMode.TRUNC);
+                } else {
+                    // Starting at some offset, append
+                    modes = EnumSet.of(OpenMode.WRITE, OpenMode.APPEND);
+                }
+                
+                log.debug("Attempting to upload {} with offset={}", local.getName(), byteOffset);
+                rf = engine.open(adjusted, modes);
                 fis = local.getInputStream();
-                rfos = rf.new RemoteFileOutputStream(0, 16);
+                fis.skip(byteOffset);
+                rfos = rf.new RemoteFileOutputStream(byteOffset, 16);
                 new StreamCopier(fis, rfos, engine.getLoggerFactory())
                         .bufSize(engine.getSubsystem().getRemoteMaxPacketSize() - rf.getOutgoingPacketOverhead())
                         .keepFlushing(false)
@@ -294,7 +333,7 @@ public class SFTPFileTransfer
             }
         }
 
-        private String prepareFile(final LocalSourceFile local, final String remote)
+        private String prepareFile(final LocalSourceFile local, final String remote, final long byteOffset)
                 throws IOException {
             final FileAttributes attrs;
             try {
@@ -309,7 +348,7 @@ public class SFTPFileTransfer
             if (attrs.getMode().getType() == FileMode.Type.DIRECTORY) {
                 throw new IOException("Trying to upload file " + local.getName() + " to path " + remote + " but that is a directory");
             } else {
-                log.debug("probeFile: {} is a {} file that will be replaced", remote, attrs.getMode().getType());
+                log.debug("probeFile: {} is a {} file that will be {}", remote, attrs.getMode().getType(), byteOffset > 0 ? "resumed" : "replaced");
                 return remote;
             }
         }

src/main/java/net/schmizz/sshj/sftp/StatefulSFTPClient.java

@@ -15,6 +15,7 @@
  */
 package net.schmizz.sshj.sftp;
 
+import net.schmizz.sshj.connection.channel.direct.SessionFactory;
 import net.schmizz.sshj.xfer.LocalDestFile;
 import net.schmizz.sshj.xfer.LocalSourceFile;
 
@@ -34,6 +35,12 @@ public class StatefulSFTPClient
         log.debug("Start dir = {}", cwd);
     }
 
+    public StatefulSFTPClient(SessionFactory sessionFactory) throws IOException {
+        super(sessionFactory);
+        this.cwd = getSFTPEngine().canonicalize(".");
+        log.debug("Start dir = {}", cwd);
+    }
+
     private synchronized String cwdify(String path) {
         return engine.getPathHelper().adjustForParent(cwd, path);
     }

src/main/java/net/schmizz/sshj/transport/Converter.java

@@ -51,6 +51,14 @@ abstract class Converter {
         return seq;
     }
 
+    void resetSequenceNumber() {
+        seq = -1;
+    }
+
+    boolean isSequenceNumberAtMax() {
+        return seq == 0xffffffffL;
+    }
+
     void setAlgorithms(Cipher cipher, MAC mac, Compression compression) {
         this.cipher = cipher;
         this.mac = mac;

src/main/java/net/schmizz/sshj/transport/KeyExchanger.java

@@ -60,6 +60,10 @@ final class KeyExchanger
 
     private final AtomicBoolean kexOngoing = new AtomicBoolean();
 
+    private final AtomicBoolean initialKex = new AtomicBoolean(true);
+
+    private final AtomicBoolean strictKex = new AtomicBoolean();
+
     /** What we are expecting from the next packet */
     private Expected expected = Expected.KEXINIT;
 
@@ -123,6 +127,14 @@ final class KeyExchanger
         return kexOngoing.get();
     }
 
+    boolean isStrictKex() {
+        return strictKex.get();
+    }
+
+    boolean isInitialKex() {
+        return initialKex.get();
+    }
+
     /**
      * Starts key exchange by sending a {@code SSH_MSG_KEXINIT} packet. Key exchange needs to be done once mandatorily
      * after initializing the {@link Transport} for it to be usable and may be initiated at any later point e.g. if
@@ -136,13 +148,25 @@ final class KeyExchanger
     void startKex(boolean waitForDone)
             throws TransportException {
         if (!kexOngoing.getAndSet(true)) {
-            done.clear();
-            sendKexInit();
+            if (isKeyExchangeAllowed()) {
+                log.debug("Initiating key exchange");
+                done.clear();
+                sendKexInit();
+            } else {
+                kexOngoing.set(false);
+            }
         }
         if (waitForDone)
             waitForDone();
     }
 
+    /**
+     * Key exchange can be initiated exactly once while connecting or later after authentication when re-keying.
+     */
+    private boolean isKeyExchangeAllowed() {
+        return !isKexDone() || transport.isAuthenticated();
+    }
+
     void waitForDone()
             throws TransportException {
         done.await(transport.getTimeoutMs(), TimeUnit.MILLISECONDS);
@@ -171,7 +195,7 @@ final class KeyExchanger
             throws TransportException {
         log.debug("Sending SSH_MSG_KEXINIT");
         List<String> knownHostAlgs = findKnownHostAlgs(transport.getRemoteHost(), transport.getRemotePort());
-        clientProposal = new Proposal(transport.getConfig(), knownHostAlgs);
+        clientProposal = new Proposal(transport.getConfig(), knownHostAlgs, initialKex.get());
         transport.write(clientProposal.getPacket());
         kexInitSent.set();
     }
@@ -190,6 +214,9 @@ final class KeyExchanger
             throws TransportException {
         log.debug("Sending SSH_MSG_NEWKEYS");
         transport.write(new SSHPacket(Message.NEWKEYS));
+        if (strictKex.get()) {
+            transport.getEncoder().resetSequenceNumber();
+        }
     }
 
     /**
@@ -222,6 +249,10 @@ final class KeyExchanger
 
     private void setKexDone() {
         kexOngoing.set(false);
+        initialKex.set(false);
+        if (strictKex.get()) {
+            transport.getDecoder().resetSequenceNumber();
+        }
         kexInitSent.clear();
         done.set();
     }
@@ -230,6 +261,7 @@ final class KeyExchanger
             throws TransportException {
         buf.rpos(buf.rpos() - 1);
         final Proposal serverProposal = new Proposal(buf);
+        gotStrictKexInfo(serverProposal);
         negotiatedAlgs = clientProposal.negotiate(serverProposal);
         log.debug("Negotiated algorithms: {}", negotiatedAlgs);
         for(AlgorithmsVerifier v: algorithmVerifiers) {
@@ -243,7 +275,6 @@ final class KeyExchanger
                                         negotiatedAlgs.getKeyExchangeAlgorithm());
         transport.setHostKeyAlgorithm(Factory.Named.Util.create(transport.getConfig().getKeyAlgorithms(),
                                       negotiatedAlgs.getSignatureAlgorithm()));
-        transport.setRSASHA2Support(negotiatedAlgs.getRSASHA2Support());
 
         try {
             kex.init(transport,
@@ -254,6 +285,18 @@ final class KeyExchanger
         }
     }
 
+    private void gotStrictKexInfo(Proposal serverProposal) throws TransportException {
+        if (initialKex.get() && serverProposal.isStrictKeyExchangeSupportedByServer()) {
+            strictKex.set(true);
+            log.debug("Enabling strict key exchange extension");
+            if (transport.getDecoder().getSequenceNumber() != 0) {
+                throw new TransportException(DisconnectReason.KEY_EXCHANGE_FAILED,
+                    "SSH_MSG_KEXINIT was not first package during strict key exchange"
+                );
+            }
+        }
+    }
+
     /**
      * Private method used while putting new keys into use that will resize the key used to initialize the cipher to the
      * needed length.

src/main/java/net/schmizz/sshj/transport/NegotiatedAlgorithms.java

@@ -26,10 +26,8 @@ public final class NegotiatedAlgorithms {
     private final String c2sComp;
     private final String s2cComp;
 
-    private final boolean rsaSHA2Support;
-
     NegotiatedAlgorithms(String kex, String sig, String c2sCipher, String s2cCipher, String c2sMAC, String s2cMAC,
-                         String c2sComp, String s2cComp, boolean rsaSHA2Support) {
+                         String c2sComp, String s2cComp) {
         this.kex = kex;
         this.sig = sig;
         this.c2sCipher = c2sCipher;
@@ -38,7 +36,6 @@ public final class NegotiatedAlgorithms {
         this.s2cMAC = s2cMAC;
         this.c2sComp = c2sComp;
         this.s2cComp = s2cComp;
-        this.rsaSHA2Support = rsaSHA2Support;
     }
 
     public String getKeyExchangeAlgorithm() {
@@ -73,10 +70,6 @@ public final class NegotiatedAlgorithms {
         return s2cComp;
     }
 
-    public boolean getRSASHA2Support() {
-        return rsaSHA2Support;
-    }
-
     @Override
     public String toString() {
         return ("[ " +
@@ -88,7 +81,6 @@ public final class NegotiatedAlgorithms {
                 "s2cMAC=" + s2cMAC + "; " +
                 "c2sComp=" + c2sComp + "; " +
                 "s2cComp=" + s2cComp + "; " +
-                "rsaSHA2Support=" + rsaSHA2Support +
                 " ]");
     }
 

src/main/java/net/schmizz/sshj/transport/Proposal.java

@@ -15,7 +15,6 @@
  */
 package net.schmizz.sshj.transport;
 
-import com.hierynomus.sshj.key.KeyAlgorithms;
 import net.schmizz.sshj.Config;
 import net.schmizz.sshj.common.Buffer;
 import net.schmizz.sshj.common.Factory;
@@ -38,8 +37,11 @@ class Proposal {
     private final List<String> s2cComp;
     private final SSHPacket packet;
 
-    public Proposal(Config config, List<String> knownHostAlgs) {
+    public Proposal(Config config, List<String> knownHostAlgs, boolean initialKex) {
         kex = Factory.Named.Util.getNames(config.getKeyExchangeFactories());
+        if (initialKex) {
+            kex.add("kex-strict-c-v00@openssh.com");
+        }
         sig = filterKnownHostKeyAlgorithms(Factory.Named.Util.getNames(config.getKeyAlgorithms()), knownHostAlgs);
         c2sCipher = s2cCipher = Factory.Named.Util.getNames(config.getCipherFactories());
         c2sMAC = s2cMAC = Factory.Named.Util.getNames(config.getMACFactories());
@@ -92,6 +94,10 @@ class Proposal {
         return kex;
     }
 
+    public boolean isStrictKeyExchangeSupportedByServer() {
+        return kex.contains("kex-strict-s-v00@openssh.com");
+    }
+
     public List<String> getHostKeyAlgorithms() {
         return sig;
     }
@@ -140,8 +146,8 @@ class Proposal {
                 firstMatch("Client2ServerCompressionAlgorithms", this.getClient2ServerCompressionAlgorithms(),
                         other.getClient2ServerCompressionAlgorithms()),
                 firstMatch("Server2ClientCompressionAlgorithms", this.getServer2ClientCompressionAlgorithms(),
-                        other.getServer2ClientCompressionAlgorithms()),
-                other.getHostKeyAlgorithms().containsAll(KeyAlgorithms.SSH_RSA_SHA2_ALGORITHMS));
+                        other.getServer2ClientCompressionAlgorithms())
+        );
     }
 
     private List<String> filterKnownHostKeyAlgorithms(List<String> configuredKeyAlgorithms, List<String> knownHostKeyAlgorithms) {

src/main/java/net/schmizz/sshj/transport/Reader.java

@@ -29,7 +29,7 @@ public final class Reader
     public Reader(TransportImpl trans) {
         this.trans = trans;
         log = trans.getConfig().getLoggerFactory().getLogger(getClass());
-        setName("reader");
+        setName("sshj-Reader");
         setDaemon(true);
     }
 

src/main/java/net/schmizz/sshj/transport/Transport.java

@@ -15,6 +15,7 @@
  */
 package net.schmizz.sshj.transport;
 
+import com.hierynomus.sshj.common.RemoteAddressProvider;
 import com.hierynomus.sshj.key.KeyAlgorithm;
 import net.schmizz.sshj.Config;
 import net.schmizz.sshj.Service;
@@ -27,11 +28,12 @@ import net.schmizz.sshj.transport.verification.HostKeyVerifier;
 
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.util.List;
 import java.util.concurrent.TimeUnit;
 
 /** Transport layer of the SSH protocol. */
 public interface Transport
-        extends SSHPacketHandler {
+        extends SSHPacketHandler, RemoteAddressProvider {
 
     /**
      * Sets the host information and the streams to be used by this transport. Identification information is exchanged
@@ -208,7 +210,7 @@ public interface Transport
     /**
      * Specify a {@code listener} that will be notified upon disconnection.
      *
-     * @param listener
+     * @param listener Disconnect Listener to be configured
      */
     void setDisconnectListener(DisconnectListener listener);
 
@@ -223,5 +225,5 @@ public interface Transport
     void die(Exception e);
 
     KeyAlgorithm getHostKeyAlgorithm();
-    KeyAlgorithm getClientKeyAlgorithm(KeyType keyType) throws TransportException;
+    List<KeyAlgorithm> getClientKeyAlgorithms(KeyType keyType) throws TransportException;
 }

src/main/java/net/schmizz/sshj/transport/TransportImpl.java

@@ -15,6 +15,7 @@
  */
 package net.schmizz.sshj.transport;
 
+import com.hierynomus.sshj.common.ThreadNameProvider;
 import com.hierynomus.sshj.key.KeyAlgorithm;
 import com.hierynomus.sshj.key.KeyAlgorithms;
 import com.hierynomus.sshj.transport.IdentificationStringParser;
@@ -22,7 +23,6 @@ import net.schmizz.concurrent.ErrorDeliveryUtil;
 import net.schmizz.concurrent.Event;
 import net.schmizz.sshj.AbstractService;
 import net.schmizz.sshj.Config;
-import net.schmizz.sshj.SSHClient;
 import net.schmizz.sshj.Service;
 import net.schmizz.sshj.common.*;
 import net.schmizz.sshj.transport.verification.AlgorithmsVerifier;
@@ -32,6 +32,8 @@ import org.slf4j.Logger;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.net.InetSocketAddress;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
@@ -86,8 +88,6 @@ public final class TransportImpl
 
     private KeyAlgorithm hostKeyAlgorithm;
 
-    private boolean rsaSHA2Support;
-
     private final Event<TransportException> serviceAccept;
 
     private final Event<TransportException> close;
@@ -130,8 +130,8 @@ public final class TransportImpl
     public TransportImpl(Config config) {
         this.config = config;
         this.loggerFactory = config.getLoggerFactory();
-        this.serviceAccept = new Event<TransportException>("service accept", TransportException.chainer, loggerFactory);
-        this.close = new Event<TransportException>("transport close", TransportException.chainer, loggerFactory);
+        this.serviceAccept = new Event<>("service accept", TransportException.chainer, loggerFactory);
+        this.close = new Event<>("transport close", TransportException.chainer, loggerFactory);
         this.nullService = new NullService(this);
         this.service = nullService;
         this.log = loggerFactory.getLogger(getClass());
@@ -165,9 +165,20 @@ public final class TransportImpl
             throw new TransportException(e);
         }
 
+        ThreadNameProvider.setThreadName(reader, this);
         reader.start();
     }
 
+    /**
+     * Get Remote Socket Address using Connection Information
+     *
+     * @return Remote Socket Address or null when not connected
+     */
+    @Override
+    public InetSocketAddress getRemoteSocketAddress() {
+        return connInfo == null ? null : new InetSocketAddress(getRemoteHost(), getRemotePort());
+    }
+
     /**
      * TransportImpl implements its own default DisconnectListener.
      */
@@ -211,7 +222,7 @@ public final class TransportImpl
      *
      * @param buffer The buffer to read from.
      * @return empty string if full ident string has not yet been received
-     * @throws IOException
+     * @throws IOException Thrown when protocol version is not supported
      */
     private String readIdentification(Buffer.PlainBuffer buffer)
             throws IOException {
@@ -415,7 +426,7 @@ public final class TransportImpl
                     assert m != Message.KEXINIT;
                     kexer.waitForDone();
                 }
-            } else if (encoder.getSequenceNumber() == 0) // We get here every 2**32th packet
+            } else if (encoder.isSequenceNumberAtMax()) // We get here every 2**32th packet
                 kexer.startKex(true);
 
             final long seq = encoder.encode(payload);
@@ -468,9 +479,20 @@ public final class TransportImpl
 
         log.trace("Received packet {}", msg);
 
+        if (kexer.isInitialKex()) {
+            if (decoder.isSequenceNumberAtMax()) {
+                throw new TransportException(DisconnectReason.KEY_EXCHANGE_FAILED,
+                    "Sequence number of decoder is about to wrap during initial key exchange");
+            }
+            if (kexer.isStrictKex() && !isKexerPacket(msg) && msg != Message.DISCONNECT) {
+                throw new TransportException(DisconnectReason.KEY_EXCHANGE_FAILED,
+                    "Unexpected packet type during initial strict key exchange");
+            }
+        }
+
         if (msg.geq(50)) { // not a transport layer packet
             service.handle(msg, buf);
-        } else if (msg.in(20, 21) || msg.in(30, 49)) { // kex packet
+        } else if (isKexerPacket(msg)) {
             kexer.handle(msg, buf);
         } else {
             switch (msg) {
@@ -502,6 +524,10 @@ public final class TransportImpl
         }
     }
 
+    private static boolean isKexerPacket(Message msg) {
+        return msg.in(20, 21) || msg.in(30, 49);
+    }
+
     private void gotDebug(SSHPacket buf)
             throws TransportException {
         try {
@@ -544,7 +570,7 @@ public final class TransportImpl
      * Got an SSH_MSG_UNIMPLEMENTED, so lets see where we're at and act accordingly.
      *
      * @param packet The 'unimplemented' packet received
-     * @throws TransportException
+     * @throws TransportException Thrown when key exchange is ongoing
      */
     private void gotUnimplemented(SSHPacket packet)
             throws SSHException {
@@ -626,21 +652,19 @@ public final class TransportImpl
         return this.hostKeyAlgorithm;
     }
 
-    public void setRSASHA2Support(boolean rsaSHA2Support) {
-        this.rsaSHA2Support = rsaSHA2Support;
-    }
-
     @Override
-    public KeyAlgorithm getClientKeyAlgorithm(KeyType keyType) throws TransportException {
-        if (keyType != KeyType.RSA || !rsaSHA2Support) {
-            return Factory.Named.Util.create(getConfig().getKeyAlgorithms(), keyType.toString());
-        }
-
+    public List<KeyAlgorithm> getClientKeyAlgorithms(KeyType keyType) throws TransportException {
         List<Factory.Named<KeyAlgorithm>> factories = getConfig().getKeyAlgorithms();
+        List<KeyAlgorithm> available = new ArrayList<>();
         if (factories != null)
             for (Factory.Named<KeyAlgorithm> f : factories)
-                if (f.getName().equals("ssh-rsa") || KeyAlgorithms.SSH_RSA_SHA2_ALGORITHMS.contains(f.getName()))
-                    return f.create();
-        throw new TransportException("Cannot find an available KeyAlgorithm for type " + keyType);
+                if (
+                        f instanceof KeyAlgorithms.Factory && ((KeyAlgorithms.Factory) f).getKeyType().equals(keyType)
+                                || !(f instanceof KeyAlgorithms.Factory) && f.getName().equals(keyType.toString())
+                )
+                    available.add(f.create());
+        if (available.isEmpty())
+            throw new TransportException("Cannot find an available KeyAlgorithm for type " + keyType);
+        return available;
     }
 }

src/main/java/net/schmizz/sshj/transport/compression/ZlibCompression.java

@@ -15,18 +15,15 @@
  */
 package net.schmizz.sshj.transport.compression;
 
-import com.jcraft.jzlib.Deflater;
-import com.jcraft.jzlib.GZIPException;
-import com.jcraft.jzlib.Inflater;
-import com.jcraft.jzlib.JZlib;
+import java.util.zip.DataFormatException;
+import java.util.zip.Deflater;
+import java.util.zip.Inflater;
+
 import net.schmizz.sshj.common.Buffer;
 import net.schmizz.sshj.common.DisconnectReason;
-import net.schmizz.sshj.common.SSHRuntimeException;
 import net.schmizz.sshj.transport.TransportException;
 
-/** ZLib based Compression. */
-public class ZlibCompression
-        implements Compression {
+public class ZlibCompression implements Compression {
 
     /** Named factory for the ZLib Compression. */
     public static class Factory
@@ -52,19 +49,15 @@ public class ZlibCompression
 
     @Override
     public void init(Mode mode) {
-        try {
-            switch (mode) {
-                case DEFLATE:
-                    deflater = new Deflater(JZlib.Z_DEFAULT_COMPRESSION);
-                    break;
-                case INFLATE:
-                    inflater = new Inflater();
-                    break;
-                default:
-                    assert false;
-            }
-        } catch (GZIPException gze) {
-
+        switch (mode) {
+            case DEFLATE:
+                deflater = new Deflater(Deflater.DEFAULT_COMPRESSION);
+                break;
+            case INFLATE:
+                inflater = new Inflater();
+                break;
+            default:
+                assert false;
         }
     }
 
@@ -75,43 +68,32 @@ public class ZlibCompression
 
     @Override
     public void compress(Buffer buffer) {
-        deflater.setNextIn(buffer.array());
-        deflater.setNextInIndex(buffer.rpos());
-        deflater.setAvailIn(buffer.available());
+        deflater.setInput(buffer.array(), buffer.rpos(), buffer.available());
         buffer.wpos(buffer.rpos());
-        do {
-            deflater.setNextOut(tempBuf);
-            deflater.setNextOutIndex(0);
-            deflater.setAvailOut(BUF_SIZE);
-            final int status = deflater.deflate(JZlib.Z_PARTIAL_FLUSH);
-            if (status == JZlib.Z_OK) {
-                buffer.putRawBytes(tempBuf, 0, BUF_SIZE - deflater.getAvailOut());
+        while (true) {
+            final int len = deflater.deflate(tempBuf, 0, BUF_SIZE, Deflater.SYNC_FLUSH);
+            if(len > 0) {
+                buffer.putRawBytes(tempBuf, 0, len);
             } else {
-                throw new SSHRuntimeException("compress: deflate returned " + status);
+                return;
             }
-        } while (deflater.getAvailOut() == 0);
+        }
     }
 
-
     @Override
     public void uncompress(Buffer from, Buffer to)
             throws TransportException {
-        inflater.setNextIn(from.array());
-        inflater.setNextInIndex(from.rpos());
-        inflater.setAvailIn(from.available());
+        inflater.setInput(from.array(), from.rpos(), from.available());
         while (true) {
-            inflater.setNextOut(tempBuf);
-            inflater.setNextOutIndex(0);
-            inflater.setAvailOut(BUF_SIZE);
-            final int status = inflater.inflate(JZlib.Z_PARTIAL_FLUSH);
-            switch (status) {
-                case JZlib.Z_OK:
-                    to.putRawBytes(tempBuf, 0, BUF_SIZE - inflater.getAvailOut());
-                    break;
-                case JZlib.Z_BUF_ERROR:
+            try {
+                int len = inflater.inflate(tempBuf, 0, BUF_SIZE);
+                if(len > 0) {
+                    to.putRawBytes(tempBuf, 0, len);
+                } else {
                     return;
-                default:
-                    throw new TransportException(DisconnectReason.COMPRESSION_ERROR, "uncompress: inflate returned " + status);
+                }
+            } catch (DataFormatException e) {
+                throw new TransportException(DisconnectReason.COMPRESSION_ERROR, "uncompress: inflate returned " + e.getMessage());
             }
         }
     }

src/main/java/net/schmizz/sshj/transport/kex/Curve25519DH.java

@@ -15,50 +15,89 @@
  */
 package net.schmizz.sshj.transport.kex;
 
-import com.hierynomus.sshj.common.KeyAlgorithm;
 import net.schmizz.sshj.common.Factory;
+import net.schmizz.sshj.common.SecurityUtils;
 import net.schmizz.sshj.transport.random.Random;
-import org.bouncycastle.asn1.x9.X9ECParameters;
-import org.bouncycastle.crypto.ec.CustomNamedCurves;
-import org.bouncycastle.jce.spec.ECParameterSpec;
-
 import java.math.BigInteger;
 import java.security.GeneralSecurityException;
+import java.security.KeyFactory;
+import java.security.KeyPair;
+import java.security.PublicKey;
 import java.security.spec.AlgorithmParameterSpec;
-import java.util.Arrays;
+import java.security.spec.KeySpec;
+import java.security.spec.X509EncodedKeySpec;
 
+/**
+ * Key Exchange Method using Curve25519 as defined in RFC 8731
+ */
 public class Curve25519DH extends DHBase {
 
-    private byte[] secretKey;
+    private static final String ALGORITHM = "X25519";
+
+    private static final int ENCODED_ALGORITHM_ID_KEY_LENGTH = 44;
+
+    private static final int ALGORITHM_ID_LENGTH = 12;
+
+    private static final int KEY_LENGTH = 32;
+
+    private final byte[] algorithmId = new byte[ALGORITHM_ID_LENGTH];
 
     public Curve25519DH() {
-        super(KeyAlgorithm.ECDSA, "ECDH");
-    }
-
-    @Override
-    void computeK(byte[] f) throws GeneralSecurityException {
-        byte[] k = new byte[32];
-        djb.Curve25519.curve(k, secretKey, f);
-        setK(new BigInteger(1, k));
-    }
-
-    @Override
-    public void init(AlgorithmParameterSpec params, Factory<Random> randomFactory) throws GeneralSecurityException {
-        Random random = randomFactory.create();
-        byte[] secretBytes =  new byte[32];
-        random.fill(secretBytes);
-        byte[] publicBytes = new byte[32];
-        djb.Curve25519.keygen(publicBytes, null, secretBytes);
-        this.secretKey = Arrays.copyOf(secretBytes, secretBytes.length);
-        setE(publicBytes);
+        super(ALGORITHM, ALGORITHM);
     }
 
     /**
-     * TODO want to figure out why BouncyCastle does not work.
-     * @return The initialized curve25519 parameter spec
+     * Compute Shared Secret Key using Diffie-Hellman Curve25519 known as X25519
+     *
+     * @param peerPublicKey Peer public key bytes
+     * @throws GeneralSecurityException Thrown on key agreement failures
      */
-    public static AlgorithmParameterSpec getCurve25519Params() {
-        X9ECParameters ecP = CustomNamedCurves.getByName("curve25519");
-        return new ECParameterSpec(ecP.getCurve(), ecP.getG(), ecP.getN(), ecP.getH(), ecP.getSeed());
+    @Override
+    void computeK(final byte[] peerPublicKey) throws GeneralSecurityException {
+        final KeyFactory keyFactory = SecurityUtils.getKeyFactory(ALGORITHM);
+        final KeySpec peerPublicKeySpec = getPeerPublicKeySpec(peerPublicKey);
+        final PublicKey generatedPeerPublicKey = keyFactory.generatePublic(peerPublicKeySpec);
+
+        agreement.doPhase(generatedPeerPublicKey, true);
+        final byte[] sharedSecretKey = agreement.generateSecret();
+        final BigInteger sharedSecretNumber = new BigInteger(BigInteger.ONE.signum(), sharedSecretKey);
+        setK(sharedSecretNumber);
+    }
+
+    /**
+     * Initialize Key Agreement with generated Public and Private Key Pair
+     *
+     * @param params Parameters not used
+     * @param randomFactory Random Factory not used
+     * @throws GeneralSecurityException Thrown on key agreement initialization failures
+     */
+    @Override
+    public void init(final AlgorithmParameterSpec params, final Factory<Random> randomFactory) throws GeneralSecurityException {
+        final KeyPair keyPair = generator.generateKeyPair();
+        agreement.init(keyPair.getPrivate());
+        setPublicKey(keyPair.getPublic());
+    }
+
+    private void setPublicKey(final PublicKey publicKey) {
+        final byte[] encoded = publicKey.getEncoded();
+
+        // Encoded public key consists of the algorithm identifier and public key
+        if (encoded.length == ENCODED_ALGORITHM_ID_KEY_LENGTH) {
+            final byte[] publicKeyEncoded = new byte[KEY_LENGTH];
+            System.arraycopy(encoded, ALGORITHM_ID_LENGTH, publicKeyEncoded, 0, KEY_LENGTH);
+            setE(publicKeyEncoded);
+
+            // Save Algorithm Identifier byte array
+            System.arraycopy(encoded, 0, algorithmId, 0, ALGORITHM_ID_LENGTH);
+        } else {
+            throw new IllegalArgumentException(String.format("X25519 unsupported public key length [%d]", encoded.length));
+        }
+    }
+
+    private KeySpec getPeerPublicKeySpec(final byte[] peerPublicKey) {
+        final byte[] encodedKeySpec = new byte[ENCODED_ALGORITHM_ID_KEY_LENGTH];
+        System.arraycopy(algorithmId, 0, encodedKeySpec, 0, ALGORITHM_ID_LENGTH);
+        System.arraycopy(peerPublicKey, 0, encodedKeySpec, ALGORITHM_ID_LENGTH, KEY_LENGTH);
+        return new X509EncodedKeySpec(encodedKeySpec);
     }
 }

src/main/java/net/schmizz/sshj/transport/kex/Curve25519SHA256.java

@@ -56,6 +56,6 @@ public class Curve25519SHA256 extends AbstractDHG {
 
     @Override
     protected void initDH(DHBase dh) throws GeneralSecurityException {
-        dh.init(Curve25519DH.getCurve25519Params(), trans.getConfig().getRandomFactory());
+        dh.init(null, trans.getConfig().getRandomFactory());
     }
 }

src/main/java/net/schmizz/sshj/transport/verification/FingerprintVerifier.java

@@ -15,16 +15,15 @@
  */
 package net.schmizz.sshj.transport.verification;
 
-import java.io.IOException;
 import java.security.GeneralSecurityException;
 import java.security.MessageDigest;
 import java.security.PublicKey;
 import java.util.Arrays;
+import java.util.Base64;
 import java.util.Collections;
 import java.util.List;
 import java.util.regex.Pattern;
 
-import net.schmizz.sshj.common.Base64;
 import net.schmizz.sshj.common.Buffer;
 import net.schmizz.sshj.common.SSHRuntimeException;
 import net.schmizz.sshj.common.SecurityUtils;
@@ -46,48 +45,40 @@ public class FingerprintVerifier implements HostKeyVerifier {
      *
      * @param fingerprint of an SSH fingerprint in MD5 (hex), SHA-1 (base64) or SHA-256(base64) format
      *
-     * @return
+     * @return Host Key Verifier
      */
     public static HostKeyVerifier getInstance(String fingerprint) {
-
-        try {
-            if (fingerprint.startsWith("SHA1:")) {
-                return new FingerprintVerifier("SHA-1", fingerprint.substring(5));
-            }
-
-            if (fingerprint.startsWith("SHA256:")) {
-                return new FingerprintVerifier("SHA-256", fingerprint.substring(7));
-            }
-
-            final String md5;
-            if (fingerprint.startsWith("MD5:")) {
-                md5 = fingerprint.substring(4); // remove the MD5: prefix
-            } else {
-                md5 = fingerprint;
-            }
-
-            if (!MD5_FINGERPRINT_PATTERN.matcher(md5).matches()) {
-                throw new SSHRuntimeException("Invalid MD5 fingerprint: " + fingerprint);
-            }
-
-            // Use the old default fingerprint verifier for md5 fingerprints
-            return (new HostKeyVerifier() {
-                @Override
-                public boolean verify(String h, int p, PublicKey k) {
-                    return SecurityUtils.getFingerprint(k).equals(md5);
-                }
-
-                @Override
-                public List<String> findExistingAlgorithms(String hostname, int port) {
-                    return Collections.emptyList();
-                }
-            });
-        } catch (SSHRuntimeException e) {
-            throw e;
-        } catch (IOException e) {
-            throw new SSHRuntimeException(e);
+        if (fingerprint.startsWith("SHA1:")) {
+            return new FingerprintVerifier("SHA-1", fingerprint.substring(5));
         }
 
+        if (fingerprint.startsWith("SHA256:")) {
+            return new FingerprintVerifier("SHA-256", fingerprint.substring(7));
+        }
+
+        final String md5;
+        if (fingerprint.startsWith("MD5:")) {
+            md5 = fingerprint.substring(4); // remove the MD5: prefix
+        } else {
+            md5 = fingerprint;
+        }
+
+        if (!MD5_FINGERPRINT_PATTERN.matcher(md5).matches()) {
+            throw new SSHRuntimeException("Invalid MD5 fingerprint: " + fingerprint);
+        }
+
+        // Use the old default fingerprint verifier for md5 fingerprints
+        return (new HostKeyVerifier() {
+            @Override
+            public boolean verify(String h, int p, PublicKey k) {
+                return SecurityUtils.getFingerprint(k).equals(md5);
+            }
+
+            @Override
+            public List<String> findExistingAlgorithms(String hostname, int port) {
+                return Collections.emptyList();
+            }
+        });
     }
 
     private final String digestAlgorithm;
@@ -99,10 +90,8 @@ public class FingerprintVerifier implements HostKeyVerifier {
      *            the used digest algorithm
      * @param base64Fingerprint
      *            base64 encoded fingerprint data
-     *
-     * @throws IOException
      */
-    private FingerprintVerifier(String digestAlgorithm, String base64Fingerprint) throws IOException {
+    private FingerprintVerifier(String digestAlgorithm, String base64Fingerprint) {
         this.digestAlgorithm = digestAlgorithm;
 
         // if the length is not padded with "=" chars at the end so that it is divisible by 4 the SSHJ Base64 implementation does not work correctly
@@ -110,7 +99,7 @@ public class FingerprintVerifier implements HostKeyVerifier {
         while (base64FingerprintBuilder.length() % 4 != 0) {
             base64FingerprintBuilder.append("=");
         }
-        fingerprintData = Base64.decode(base64FingerprintBuilder.toString());
+        fingerprintData = Base64.getDecoder().decode(base64FingerprintBuilder.toString());
     }
 
     @Override

src/main/java/net/schmizz/sshj/transport/verification/OpenSSHKnownHosts.java

@@ -18,15 +18,31 @@ package net.schmizz.sshj.transport.verification;
 import com.hierynomus.sshj.common.KeyAlgorithm;
 import com.hierynomus.sshj.transport.verification.KnownHostMatchers;
 import com.hierynomus.sshj.userauth.certificate.Certificate;
-import net.schmizz.sshj.common.*;
+import net.schmizz.sshj.common.Buffer;
+import net.schmizz.sshj.common.IOUtils;
+import net.schmizz.sshj.common.KeyType;
+import net.schmizz.sshj.common.LoggerFactory;
+import net.schmizz.sshj.common.SSHException;
+import net.schmizz.sshj.common.SSHRuntimeException;
+import net.schmizz.sshj.common.SecurityUtils;
 import org.slf4j.Logger;
 
-import java.io.*;
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Reader;
 import java.math.BigInteger;
 import java.security.KeyFactory;
 import java.security.PublicKey;
 import java.security.spec.RSAPublicKeySpec;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Base64;
 import java.util.List;
 
 /**
@@ -138,7 +154,19 @@ public class OpenSSHKnownHosts
         for (KnownHostEntry e : entries) {
             try {
                 if (e.appliesTo(adjustedHostname)) {
-                    knownHostAlgorithms.add(e.getType().toString());
+                    final KeyType type = e.getType();
+                    if (e instanceof HostEntry && ((HostEntry) e).marker == Marker.CA_CERT) {
+                        // Only the CA key type is known, but the type of the host key is not.
+                        // Adding all supported types for keys with certificates.
+                        for (final KeyType candidate : KeyType.values()) {
+                            if (candidate.getParent() != null) {
+                                knownHostAlgorithms.add(candidate.toString());
+                            }
+                        }
+                    }
+                    else {
+                        knownHostAlgorithms.add(type.toString());
+                    }
                 }
             } catch (IOException ioe) {
             }
@@ -262,7 +290,7 @@ public class OpenSSHKnownHosts
             if (type != KeyType.UNKNOWN) {
                 final String sKey = split[i++];
                 try {
-                    byte[] keyBytes = Base64.decode(sKey);
+                    byte[] keyBytes = Base64.getDecoder().decode(sKey);
                     key = new Buffer.PlainBuffer(keyBytes).readPublicKey();
                 } catch (IOException ioe) {
                     log.warn("Error decoding Base64 key bytes", ioe);
@@ -442,7 +470,7 @@ public class OpenSSHKnownHosts
 
         private String getKeyString(PublicKey pk) {
             final Buffer.PlainBuffer buf = new Buffer.PlainBuffer().putPublicKey(pk);
-            return Base64.encodeBytes(buf.array(), buf.rpos(), buf.available());
+            return Base64.getEncoder().encodeToString(Arrays.copyOfRange(buf.array(), buf.rpos(), buf.available()));
         }
 
         protected String getHostPart() {

src/main/java/net/schmizz/sshj/userauth/keyprovider/KeyFormat.java

@@ -16,10 +16,9 @@
 package net.schmizz.sshj.userauth.keyprovider;
 
 /**
-* @version $Id:$
+* Key File Formats
 */
 public enum KeyFormat {
-    PKCS5,
     PKCS8,
     OpenSSH,
     OpenSSHv1,

src/main/java/net/schmizz/sshj/userauth/keyprovider/KeyProviderUtil.java

@@ -27,9 +27,9 @@ public class KeyProviderUtil {
      * <p/>
      * Return values are consistent with the {@code NamedFactory} implementations in the {@code keyprovider} package.
      *
-     * @param location
+     * @param location File Path to key
      * @return name of the key file format
-     * @throws java.io.IOException
+     * @throws java.io.IOException Thrown on file processing failures
      */
     public static KeyFormat detectKeyFileFormat(File location)
             throws IOException {
@@ -45,7 +45,7 @@ public class KeyProviderUtil {
      * @param privateKey     Private key stored in a string
      * @param separatePubKey Is the public key stored separately from the private key
      * @return name of the key file format
-     * @throws java.io.IOException
+     * @throws java.io.IOException Thrown on file processing failures
      */
     public static KeyFormat detectKeyFileFormat(String privateKey, boolean separatePubKey)
             throws IOException {
@@ -60,7 +60,7 @@ public class KeyProviderUtil {
      * @param privateKey     Private key accessible through a {@code Reader}
      * @param separatePubKey Is the public key stored separately from the private key
      * @return name of the key file format
-     * @throws java.io.IOException
+     * @throws java.io.IOException Thrown on file processing failures
      */
     public static KeyFormat detectKeyFileFormat(Reader privateKey, boolean separatePubKey)
             throws IOException {
@@ -94,10 +94,8 @@ public class KeyProviderUtil {
             } else if (separatePubKey) {
                 // Can delay asking for password since have unencrypted pubkey
                 return KeyFormat.OpenSSH;
-            } else if (header.contains("BEGIN PRIVATE KEY") || header.contains("BEGIN ENCRYPTED PRIVATE KEY")) {
-                return KeyFormat.PKCS8;
             } else {
-                return KeyFormat.PKCS5;
+                return KeyFormat.PKCS8;
             }
         } else if (header.startsWith("PuTTY-User-Key-File-")) {
             return KeyFormat.PuTTY;

src/main/java/net/schmizz/sshj/userauth/keyprovider/PKCS5KeyFile.java

@@ -1,272 +0,0 @@
-/*
- * Copyright (C)2009 - SSHJ Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package net.schmizz.sshj.userauth.keyprovider;
-
-import com.hierynomus.sshj.common.KeyAlgorithm;
-import com.hierynomus.sshj.transport.cipher.BlockCiphers;
-import net.schmizz.sshj.common.Base64;
-import net.schmizz.sshj.common.ByteArrayUtils;
-import net.schmizz.sshj.common.IOUtils;
-import net.schmizz.sshj.common.KeyType;
-import net.schmizz.sshj.transport.cipher.*;
-import net.schmizz.sshj.transport.digest.Digest;
-import net.schmizz.sshj.transport.digest.MD5;
-
-import java.io.BufferedReader;
-import java.io.EOFException;
-import java.io.IOException;
-import java.math.BigInteger;
-import java.nio.ByteBuffer;
-import java.nio.CharBuffer;
-import java.security.*;
-import java.security.spec.*;
-import java.util.Arrays;
-
-/**
- * Represents a PKCS5-encoded key file. This is the format typically used by OpenSSH, OpenSSL, Amazon, etc.
- */
-public class PKCS5KeyFile extends BaseFileKeyProvider {
-
-    public static class Factory
-            implements net.schmizz.sshj.common.Factory.Named<FileKeyProvider> {
-
-        @Override
-        public FileKeyProvider create() {
-            return new PKCS5KeyFile();
-        }
-
-        @Override
-        public String getName() {
-            return "PKCS5";
-        }
-    }
-
-    /**
-     * Indicates a format issue with PKCS5 data
-     */
-    public static class FormatException
-            extends IOException {
-
-        FormatException(String msg) {
-            super(msg);
-        }
-    }
-
-    /**
-     * Indicates a problem decrypting the data
-     */
-    public static class DecryptException
-            extends IOException {
-
-        DecryptException(String msg) {
-            super(msg);
-        }
-    }
-
-    protected byte[] data;
-
-    protected KeyPair readKeyPair()
-            throws IOException {
-
-        BufferedReader reader = new BufferedReader(resource.getReader());
-        try {
-            String line = null;
-            Cipher cipher = new NoneCipher();
-            StringBuffer sb = new StringBuffer();
-            byte[] iv = new byte[0]; // salt
-            while ((line = reader.readLine()) != null) {
-                if (line.startsWith("-----BEGIN ") && line.endsWith(" PRIVATE KEY-----")) {
-                    int end = line.length() - 17;
-                    if (end > 11) {
-                        String s = line.substring(11, line.length() - 17);
-                        if ("RSA".equals(s)) {
-                            type = KeyType.RSA;
-                        } else if ("DSA".equals(s)) {
-                            type = KeyType.DSA;
-                        } else if ("DSS".equals(s)) {
-                            type = KeyType.DSA;
-                        } else {
-                            throw new FormatException("Unrecognized PKCS5 key type");
-                        }
-                    } else {
-                        throw new FormatException("Bad header; possibly PKCS8 format?");
-                    }
-                } else if (line.startsWith("-----END")) {
-                    break;
-                } else if (type != null) {
-                    if (line.startsWith("Proc-Type: ")) {
-                        if (!"4,ENCRYPTED".equals(line.substring(11))) {
-                            throw new FormatException("Unrecognized Proc-Type");
-                        }
-                    } else if (line.startsWith("DEK-Info: ")) {
-                        int ptr = line.indexOf(",");
-                        if (ptr == -1) {
-                            throw new FormatException("Unrecognized DEK-Info");
-                        } else {
-                            String algorithm = line.substring(10, ptr);
-                            if ("DES-EDE3-CBC".equals(algorithm)) {
-                                cipher = BlockCiphers.TripleDESCBC().create();
-                            } else if ("AES-128-CBC".equals(algorithm)) {
-                                cipher = BlockCiphers.AES128CBC().create();
-                            } else if ("AES-192-CBC".equals(algorithm)) {
-                                cipher = BlockCiphers.AES192CBC().create();
-                            } else if ("AES-256-CBC".equals(algorithm)) {
-                                cipher = BlockCiphers.AES256CBC().create();
-                            } else {
-                                throw new FormatException("Not a supported algorithm: " + algorithm);
-                            }
-                            iv = Arrays.copyOfRange(ByteArrayUtils.parseHex(line.substring(ptr + 1)), 0, cipher.getIVSize());
-                        }
-                    } else if (line.length() > 0) {
-                        sb.append(line);
-                    }
-                }
-            }
-            if (type == null) {
-                throw new FormatException("PKCS5 header not found");
-            }
-            ASN1Data asn = new ASN1Data(data = decrypt(Base64.decode(sb.toString()), cipher, iv));
-            switch (type) {
-                case RSA: {
-                    KeyFactory factory = KeyFactory.getInstance(KeyAlgorithm.RSA);
-                    asn.readNext();
-                    BigInteger modulus = asn.readNext();
-                    BigInteger pubExp = asn.readNext();
-                    BigInteger prvExp = asn.readNext();
-                    PublicKey pubKey = factory.generatePublic(new RSAPublicKeySpec(modulus, pubExp));
-                    PrivateKey prvKey = factory.generatePrivate(new RSAPrivateKeySpec(modulus, prvExp));
-                    return new KeyPair(pubKey, prvKey);
-                }
-                case DSA: {
-                    KeyFactory factory = KeyFactory.getInstance(KeyAlgorithm.DSA);
-                    asn.readNext();
-                    BigInteger p = asn.readNext();
-                    BigInteger q = asn.readNext();
-                    BigInteger g = asn.readNext();
-                    BigInteger pub = asn.readNext();
-                    BigInteger prv = asn.readNext();
-                    PublicKey pubKey = factory.generatePublic(new DSAPublicKeySpec(pub, p, q, g));
-                    PrivateKey prvKey = factory.generatePrivate(new DSAPrivateKeySpec(prv, p, q, g));
-                    return new KeyPair(pubKey, prvKey);
-                }
-                default:
-                    throw new IOException("Unrecognized PKCS5 key type: " + type);
-            }
-        } catch (NoSuchAlgorithmException e) {
-            throw new IOException(e);
-        } catch (InvalidKeySpecException e) {
-            throw new IOException(e);
-        } finally {
-            reader.close();
-        }
-    }
-
-    @Override
-    public String toString() {
-        return "PKCS5KeyFile{resource=" + resource + "}";
-    }
-
-    private byte[] getPassphraseBytes() {
-        CharBuffer cb = CharBuffer.wrap(pwdf.reqPassword(resource));
-        ByteBuffer bb = IOUtils.UTF8.encode(cb);
-        byte[] result = Arrays.copyOfRange(bb.array(), bb.position(), bb.limit());
-        Arrays.fill(cb.array(), '\u0000');
-        Arrays.fill(bb.array(), (byte) 0);
-        return result;
-    }
-
-    private byte[] decrypt(byte[] raw, Cipher cipher, byte[] iv) throws DecryptException {
-        if (pwdf == null) {
-            return raw;
-        }
-        Digest md5 = new MD5();
-        int bsize = cipher.getBlockSize();
-        int hsize = md5.getBlockSize();
-        int hnlen = bsize / hsize * hsize + (bsize % hsize == 0 ? 0 : hsize);
-        do {
-            md5.init();
-            byte[] hn = new byte[hnlen];
-            byte[] tmp = null;
-            byte[] passphrase = getPassphraseBytes();
-            for (int i = 0; i + hsize <= hn.length; ) {
-                if (tmp != null) {
-                    md5.update(tmp, 0, tmp.length);
-                }
-                md5.update(passphrase, 0, passphrase.length);
-                md5.update(iv, 0, iv.length > 8 ? 8 : iv.length);
-                tmp = md5.digest();
-                System.arraycopy(tmp, 0, hn, i, tmp.length);
-                i += tmp.length;
-            }
-            Arrays.fill(passphrase, (byte) 0);
-            byte[] key = Arrays.copyOfRange(hn, 0, bsize);
-            cipher.init(Cipher.Mode.Decrypt, key, iv);
-            Arrays.fill(key, (byte) 0);
-            byte[] decrypted = Arrays.copyOf(raw, raw.length);
-            cipher.update(decrypted, 0, decrypted.length);
-            if (ASN1Data.MAGIC == decrypted[0]) {
-                return decrypted;
-            }
-        } while (pwdf.shouldRetry(resource));
-        throw new DecryptException("Decryption failed");
-    }
-
-    class ASN1Data {
-        static final byte MAGIC = (byte) 0x30;
-
-        private byte[] buff;
-        private int index, length;
-
-        ASN1Data(byte[] buff) throws FormatException {
-            this.buff = buff;
-            index = 0;
-            if (buff[index++] != MAGIC) {
-                throw new FormatException("Not ASN.1 data");
-            }
-            length = buff[index++] & 0xff;
-            if ((length & 0x80) != 0) {
-                int counter = length & 0x7f;
-                length = 0;
-                while (counter-- > 0) {
-                    length = (length << 8) + (buff[index++] & 0xff);
-                }
-            }
-            if ((index + length) > buff.length) {
-                throw new FormatException("Length mismatch: " + buff.length + " != " + (index + length));
-            }
-        }
-
-        BigInteger readNext() throws IOException {
-            if (index >= length) {
-                throw new EOFException();
-            } else if (buff[index++] != 0x02) {
-                throw new IOException("Not an int code: " + Integer.toHexString(0xff & buff[index]));
-            }
-            int length = buff[index++] & 0xff;
-            if ((length & 0x80) != 0) {
-                int counter = length & 0x7f;
-                length = 0;
-                while (counter-- > 0) {
-                    length = (length << 8) + (buff[index++] & 0xff);
-                }
-            }
-            byte[] sequence = new byte[length];
-            System.arraycopy(buff, index, sequence, 0, length);
-            index += length;
-            return new BigInteger(sequence);
-        }
-    }
-}