diff --git a/pom.xml b/pom.xml
index 5d8b186..668a33c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -112,7 +112,7 @@
             <dependency>
                 <groupId>org.apache.mina</groupId>
                 <artifactId>mina-core</artifactId>
-                <version>2.0.10</version>
+                <version>2.0.13</version>
             </dependency>
             <dependency>
                 <groupId>tomcat</groupId>
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/auth/hostbased/UserAuthHostBased.java b/sshd-core/src/main/java/org/apache/sshd/client/auth/hostbased/UserAuthHostBased.java
index e57a75b..3d8c832 100644
--- a/sshd-core/src/main/java/org/apache/sshd/client/auth/hostbased/UserAuthHostBased.java
+++ b/sshd-core/src/main/java/org/apache/sshd/client/auth/hostbased/UserAuthHostBased.java
@@ -113,7 +113,7 @@
 
         Collection<NamedFactory<Signature>> factories =
                 ValidateUtils.checkNotNullAndNotEmpty(
-                        SignatureFactoriesManager.Utils.resolveSignatureFactories(this, session),
+                        SignatureFactoriesManager.resolveSignatureFactories(this, session),
                         "No signature factories for session=%s",
                         session);
         Signature verifier = ValidateUtils.checkNotNull(
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/auth/pubkey/KeyPairIdentity.java b/sshd-core/src/main/java/org/apache/sshd/client/auth/pubkey/KeyPairIdentity.java
index 90f560e..02400cd 100644
--- a/sshd-core/src/main/java/org/apache/sshd/client/auth/pubkey/KeyPairIdentity.java
+++ b/sshd-core/src/main/java/org/apache/sshd/client/auth/pubkey/KeyPairIdentity.java
@@ -40,7 +40,7 @@
 
     public KeyPairIdentity(SignatureFactoriesManager primary, SignatureFactoriesManager secondary, KeyPair pair) {
         this.signatureFactories = ValidateUtils.checkNotNullAndNotEmpty(
-                SignatureFactoriesManager.Utils.resolveSignatureFactories(primary, secondary),
+                SignatureFactoriesManager.resolveSignatureFactories(primary, secondary),
                 "No available signature factories");
         this.pair = ValidateUtils.checkNotNull(pair, "No key pair");
     }
diff --git a/sshd-core/src/main/java/org/apache/sshd/common/kex/KexFactoryManager.java b/sshd-core/src/main/java/org/apache/sshd/common/kex/KexFactoryManager.java
index fbe4544..6776f29 100644
--- a/sshd-core/src/main/java/org/apache/sshd/common/kex/KexFactoryManager.java
+++ b/sshd-core/src/main/java/org/apache/sshd/common/kex/KexFactoryManager.java
@@ -19,14 +19,23 @@
 
 package org.apache.sshd.common.kex;
 
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 
 import org.apache.sshd.common.NamedFactory;
+import org.apache.sshd.common.NamedResource;
+import org.apache.sshd.common.cipher.BuiltinCiphers;
 import org.apache.sshd.common.cipher.Cipher;
+import org.apache.sshd.common.compression.BuiltinCompressions;
 import org.apache.sshd.common.compression.Compression;
 import org.apache.sshd.common.keyprovider.KeyPairProviderHolder;
+import org.apache.sshd.common.mac.BuiltinMacs;
 import org.apache.sshd.common.mac.Mac;
 import org.apache.sshd.common.signature.SignatureFactoriesManager;
+import org.apache.sshd.common.util.GenericUtils;
+import org.apache.sshd.common.util.ValidateUtils;
 
 /**
  * Holds KEX negotiation stage configuration
@@ -47,7 +56,29 @@
      * @return a list of named <code>Cipher</code> factories, never {@code null}
      */
     List<NamedFactory<Cipher>> getCipherFactories();
+    default String getCipherFactoriesNameList() {
+        return NamedResource.Utils.getNames(getCipherFactories());
+    }
+    default List<String> getCipherFactoriesNames() {
+        return NamedResource.Utils.getNameList(getCipherFactories());
+    }
+
     void setCipherFactories(List<NamedFactory<Cipher>> cipherFactories);
+    default void setCipherFactoriesNameList(String names) {
+        setCipherFactoriesNames(GenericUtils.split(names, ','));
+    }
+    default void setCipherFactoriesNames(String ... names) {
+        setCipherFactoriesNames(GenericUtils.isEmpty((Object[]) names) ? Collections.<String>emptyList() : Arrays.asList(names));
+    }
+    default void setCipherFactoriesNames(Collection<String> names) {
+        BuiltinCiphers.ParseResult result = BuiltinCiphers.parseCiphersList(names);
+        @SuppressWarnings({ "rawtypes", "unchecked" })
+        List<NamedFactory<Cipher>> factories =
+                (List) ValidateUtils.checkNotNullAndNotEmpty(result.getParsedFactories(), "No supported cipher factories: %s", names);
+        Collection<String> unsupported = result.getUnsupportedFactories();
+        ValidateUtils.checkTrue(GenericUtils.isEmpty(unsupported), "Unsupported cipher factories found: %s", unsupported);
+        setCipherFactories(factories);
+    }
 
     /**
      * Retrieve the list of named factories for <code>Compression</code>.
@@ -55,7 +86,29 @@
      * @return a list of named <code>Compression</code> factories, never {@code null}
      */
     List<NamedFactory<Compression>> getCompressionFactories();
+    default String getCompressionFactoriesNameList() {
+        return NamedResource.Utils.getNames(getCompressionFactories());
+    }
+    default List<String> getCompressionFactoriesNames() {
+        return NamedResource.Utils.getNameList(getCompressionFactories());
+    }
+
     void setCompressionFactories(List<NamedFactory<Compression>> compressionFactories);
+    default void setCompressionFactoriesNameList(String names) {
+        setCompressionFactoriesNames(GenericUtils.split(names, ','));
+    }
+    default void setCompressionFactoriesNames(String ... names) {
+        setCompressionFactoriesNames(GenericUtils.isEmpty((Object[]) names) ? Collections.<String>emptyList() : Arrays.asList(names));
+    }
+    default void setCompressionFactoriesNames(Collection<String> names) {
+        BuiltinCompressions.ParseResult result = BuiltinCompressions.parseCompressionsList(names);
+        @SuppressWarnings({ "rawtypes", "unchecked" })
+        List<NamedFactory<Compression>> factories =
+                (List) ValidateUtils.checkNotNullAndNotEmpty(result.getParsedFactories(), "No supported compression factories: %s", names);
+        Collection<String> unsupported = result.getUnsupportedFactories();
+        ValidateUtils.checkTrue(GenericUtils.isEmpty(unsupported), "Unsupported compression factories found: %s", unsupported);
+        setCompressionFactories(factories);
+    }
 
     /**
      * Retrieve the list of named factories for <code>Mac</code>.
@@ -63,5 +116,27 @@
      * @return a list of named <code>Mac</code> factories, never {@code null}
      */
     List<NamedFactory<Mac>> getMacFactories();
+    default String getMacFactoriesNameList() {
+        return NamedResource.Utils.getNames(getMacFactories());
+    }
+    default List<String> getMacFactoriesNames() {
+        return NamedResource.Utils.getNameList(getMacFactories());
+    }
+
     void setMacFactories(List<NamedFactory<Mac>> macFactories);
+    default void setMacFactoriesNameList(String names) {
+        setMacFactoriesNames(GenericUtils.split(names, ','));
+    }
+    default void setMacFactoriesNames(String ... names) {
+        setMacFactoriesNames(GenericUtils.isEmpty((Object[]) names) ? Collections.<String>emptyList() : Arrays.asList(names));
+    }
+    default void setMacFactoriesNames(Collection<String> names) {
+        BuiltinMacs.ParseResult result = BuiltinMacs.parseMacsList(names);
+        @SuppressWarnings({ "rawtypes", "unchecked" })
+        List<NamedFactory<Mac>> factories =
+                (List) ValidateUtils.checkNotNullAndNotEmpty(result.getParsedFactories(), "No supported MAC factories: %s", names);
+        Collection<String> unsupported = result.getUnsupportedFactories();
+        ValidateUtils.checkTrue(GenericUtils.isEmpty(unsupported), "Unsupported MAC factories found: %s", unsupported);
+        setMacFactories(factories);
+    }
 }
diff --git a/sshd-core/src/main/java/org/apache/sshd/common/signature/SignatureFactoriesManager.java b/sshd-core/src/main/java/org/apache/sshd/common/signature/SignatureFactoriesManager.java
index 696f47c..ff07743 100644
--- a/sshd-core/src/main/java/org/apache/sshd/common/signature/SignatureFactoriesManager.java
+++ b/sshd-core/src/main/java/org/apache/sshd/common/signature/SignatureFactoriesManager.java
@@ -19,10 +19,15 @@
 
 package org.apache.sshd.common.signature;
 
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 
 import org.apache.sshd.common.NamedFactory;
+import org.apache.sshd.common.NamedResource;
 import org.apache.sshd.common.util.GenericUtils;
+import org.apache.sshd.common.util.ValidateUtils;
 
 /**
  * Manage the list of named factories for <code>Signature</code>.
@@ -34,40 +39,51 @@
      * @return The list of named <code>Signature</code> factories
      */
     List<NamedFactory<Signature>> getSignatureFactories();
+    default String getSignatureFactoriesNameList() {
+        return NamedResource.Utils.getNames(getSignatureFactories());
+    }
+    default List<String> getSignatureFactoriesNames() {
+        return NamedResource.Utils.getNameList(getSignatureFactories());
+    }
+
     void setSignatureFactories(List<NamedFactory<Signature>> factories);
+    default void setSignatureFactoriesNameList(String names) {
+        setSignatureFactoriesNames(GenericUtils.split(names, ','));
+    }
+    default void setSignatureFactoriesNames(String ... names) {
+        setSignatureFactoriesNames(GenericUtils.isEmpty((Object[]) names) ? Collections.<String>emptyList() : Arrays.asList(names));
+    }
+    default void setSignatureFactoriesNames(Collection<String> names) {
+        BuiltinSignatures.ParseResult result = BuiltinSignatures.parseSignatureList(names);
+        @SuppressWarnings({ "rawtypes", "unchecked" })
+        List<NamedFactory<Signature>> factories =
+                (List) ValidateUtils.checkNotNullAndNotEmpty(result.getParsedFactories(), "No supported signature factories: %s", names);
+        Collection<String> unsupported = result.getUnsupportedFactories();
+        ValidateUtils.checkTrue(GenericUtils.isEmpty(unsupported), "Unsupported signature factories found: %s", unsupported);
+        setSignatureFactories(factories);
+    }
 
     /**
-     * A helper class for signature factories related operations
-     * @author <a href="mailto:dev@mina.apache.org">Apache MINA SSHD Project</a>
+     * Attempts to use the primary manager's signature factories if not {@code null}/empty,
+     * otherwise uses the secondary ones (regardless of whether there are any...)
+     *
+     * @param primary The primary {@link SignatureFactoriesManager}
+     * @param secondary The secondary {@link SignatureFactoriesManager}
+     * @return The resolved signature factories - may be {@code null}/empty
+     * @see #getSignatureFactories(SignatureFactoriesManager)
      */
-    // CHECKSTYLE:OFF
-    final class Utils {
-        private Utils() {
-            throw new UnsupportedOperationException("No instance allowed");
-        }
+    static List<NamedFactory<Signature>> resolveSignatureFactories(
+            SignatureFactoriesManager primary, SignatureFactoriesManager secondary) {
+        List<NamedFactory<Signature>> factories = getSignatureFactories(primary);
+        return GenericUtils.isEmpty(factories) ? getSignatureFactories(secondary) : factories;
+    }
 
-        /**
-         * @param manager The {@link SignatureFactoriesManager} instance - ignored if {@code null}
-         * @return The associated list of named <code>Signature</code> factories or {@code null} if
-         * no manager instance
-         */
-        public static List<NamedFactory<Signature>> getSignatureFactories(SignatureFactoriesManager manager) {
-            return (manager == null) ? null : manager.getSignatureFactories();
-        }
-
-        /**
-         * Attempts to use the primary manager's signature factories if not {@code null}/empty,
-         * otherwise uses the secondary ones (regardless of whether there are any...)
-         *
-         * @param primary The primary {@link SignatureFactoriesManager}
-         * @param secondary The secondary {@link SignatureFactoriesManager}
-         * @return The resolved signature factories - may be {@code null}/empty
-         * @see #getSignatureFactories(SignatureFactoriesManager)
-         */
-        public static List<NamedFactory<Signature>> resolveSignatureFactories(
-                SignatureFactoriesManager primary, SignatureFactoriesManager secondary) {
-            List<NamedFactory<Signature>> factories = getSignatureFactories(primary);
-            return GenericUtils.isEmpty(factories) ? getSignatureFactories(secondary) : factories;
-        }
+    /**
+     * @param manager The {@link SignatureFactoriesManager} instance - ignored if {@code null}
+     * @return The associated list of named <code>Signature</code> factories or {@code null} if
+     * no manager instance
+     */
+    static List<NamedFactory<Signature>> getSignatureFactories(SignatureFactoriesManager manager) {
+        return (manager == null) ? null : manager.getSignatureFactories();
     }
 }
diff --git a/sshd-core/src/main/java/org/apache/sshd/server/auth/hostbased/UserAuthHostBased.java b/sshd-core/src/main/java/org/apache/sshd/server/auth/hostbased/UserAuthHostBased.java
index dcdd3a9..2921437 100644
--- a/sshd-core/src/main/java/org/apache/sshd/server/auth/hostbased/UserAuthHostBased.java
+++ b/sshd-core/src/main/java/org/apache/sshd/server/auth/hostbased/UserAuthHostBased.java
@@ -140,7 +140,7 @@
         // verify signature
         Collection<NamedFactory<Signature>> factories =
                 ValidateUtils.checkNotNullAndNotEmpty(
-                        SignatureFactoriesManager.Utils.resolveSignatureFactories(this, session),
+                        SignatureFactoriesManager.resolveSignatureFactories(this, session),
                         "No signature factories for session=%s",
                         session);
         Signature verifier = ValidateUtils.checkNotNull(
diff --git a/sshd-core/src/main/java/org/apache/sshd/server/auth/pubkey/UserAuthPublicKey.java b/sshd-core/src/main/java/org/apache/sshd/server/auth/pubkey/UserAuthPublicKey.java
index d6b0469..e52f176 100644
--- a/sshd-core/src/main/java/org/apache/sshd/server/auth/pubkey/UserAuthPublicKey.java
+++ b/sshd-core/src/main/java/org/apache/sshd/server/auth/pubkey/UserAuthPublicKey.java
@@ -83,7 +83,7 @@
         PublicKey key = buffer.getRawPublicKey();
         Collection<NamedFactory<Signature>> factories =
                 ValidateUtils.checkNotNullAndNotEmpty(
-                        SignatureFactoriesManager.Utils.resolveSignatureFactories(this, session),
+                        SignatureFactoriesManager.resolveSignatureFactories(this, session),
                         "No signature factories for session=%s",
                         session);
         if (log.isDebugEnabled()) {
diff --git a/sshd-core/src/main/java/org/apache/sshd/server/global/OpenSshHostKeysHandler.java b/sshd-core/src/main/java/org/apache/sshd/server/global/OpenSshHostKeysHandler.java
index a90ffd5..e84f82c 100644
--- a/sshd-core/src/main/java/org/apache/sshd/server/global/OpenSshHostKeysHandler.java
+++ b/sshd-core/src/main/java/org/apache/sshd/server/global/OpenSshHostKeysHandler.java
@@ -87,7 +87,7 @@
         ValidateUtils.checkTrue(wantReply, "No reply required for host keys of %s", session);
         Collection<? extends NamedFactory<Signature>> factories =
                 ValidateUtils.checkNotNullAndNotEmpty(
-                        SignatureFactoriesManager.Utils.resolveSignatureFactories(this, session),
+                        SignatureFactoriesManager.resolveSignatureFactories(this, session),
                         "No signature factories available for host keys of session=%s",
                         session);
         if (log.isDebugEnabled()) {
diff --git a/sshd-core/src/test/java/org/apache/sshd/common/kex/KexFactoryManagerTest.java b/sshd-core/src/test/java/org/apache/sshd/common/kex/KexFactoryManagerTest.java
new file mode 100644
index 0000000..ed2f9e3
--- /dev/null
+++ b/sshd-core/src/test/java/org/apache/sshd/common/kex/KexFactoryManagerTest.java
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.sshd.common.kex;
+
+import java.util.List;
+
+import org.apache.sshd.common.NamedFactory;
+import org.apache.sshd.common.NamedResource;
+import org.apache.sshd.common.cipher.BuiltinCiphers;
+import org.apache.sshd.common.cipher.Cipher;
+import org.apache.sshd.common.compression.BuiltinCompressions;
+import org.apache.sshd.common.compression.Compression;
+import org.apache.sshd.common.keyprovider.KeyPairProvider;
+import org.apache.sshd.common.mac.BuiltinMacs;
+import org.apache.sshd.common.mac.Mac;
+import org.apache.sshd.common.signature.BuiltinSignatures;
+import org.apache.sshd.common.signature.Signature;
+import org.apache.sshd.common.util.GenericUtils;
+import org.apache.sshd.util.test.BaseTestSupport;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+/**
+ * @author <a href="mailto:dev@mina.apache.org">Apache MINA SSHD Project</a>
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class KexFactoryManagerTest extends BaseTestSupport {
+    public KexFactoryManagerTest() {
+        super();
+    }
+
+    @Test
+    public void testDefaultCompressionFactoriesMethods() {
+        KexFactoryManager manager =  new TestKexFactoryManager();
+        assertEquals("Mismatched empty factories name list", "", manager.getCompressionFactoriesNameList());
+
+        String expected = NamedResource.Utils.getNames(BuiltinCompressions.VALUES);
+        manager.setCompressionFactoriesNameList(expected);
+        assertEquals("Mismatched updated factories name list", expected, manager.getCompressionFactoriesNameList());
+
+        List<NamedFactory<Compression>> factories = manager.getCompressionFactories();
+        assertEquals("Mismatched updated factories count", BuiltinCompressions.VALUES.size(), GenericUtils.size(factories));
+
+        for (NamedFactory<Compression> f : BuiltinCompressions.VALUES) {
+            assertTrue("Factory not set: " + f, factories.contains(f));
+        }
+    }
+
+    @Test
+    public void testDefaultCipherFactoriesMethods() {
+        KexFactoryManager manager =  new TestKexFactoryManager();
+        assertEquals("Mismatched empty factories name list", "", manager.getCipherFactoriesNameList());
+
+        String expected = NamedResource.Utils.getNames(BuiltinCiphers.VALUES);
+        manager.setCipherFactoriesNameList(expected);
+        assertEquals("Mismatched updated factories name list", expected, manager.getCipherFactoriesNameList());
+
+        List<NamedFactory<Cipher>> factories = manager.getCipherFactories();
+        assertEquals("Mismatched updated factories count", BuiltinCiphers.VALUES.size(), GenericUtils.size(factories));
+
+        for (NamedFactory<Cipher> f : BuiltinCiphers.VALUES) {
+            assertTrue("Factory not set: " + f, factories.contains(f));
+        }
+    }
+
+    @Test
+    public void testDefaultMacFactoriesMethods() {
+        KexFactoryManager manager =  new TestKexFactoryManager();
+        assertEquals("Mismatched empty factories name list", "", manager.getMacFactoriesNameList());
+
+        String expected = NamedResource.Utils.getNames(BuiltinMacs.VALUES);
+        manager.setMacFactoriesNameList(expected);
+        assertEquals("Mismatched updated factories name list", expected, manager.getMacFactoriesNameList());
+
+        List<NamedFactory<Mac>> factories = manager.getMacFactories();
+        assertEquals("Mismatched updated factories count", BuiltinMacs.VALUES.size(), GenericUtils.size(factories));
+
+        for (NamedFactory<Mac> f : BuiltinMacs.VALUES) {
+            assertTrue("Factory not set: " + f, factories.contains(f));
+        }
+    }
+
+    @Test
+    public void testDefaultSignatureFactoriesMethods() {
+        KexFactoryManager manager =  new TestKexFactoryManager();
+        assertEquals("Mismatched empty factories name list", "", manager.getSignatureFactoriesNameList());
+
+        String expected = NamedResource.Utils.getNames(BuiltinSignatures.VALUES);
+        manager.setSignatureFactoriesNameList(expected);
+        assertEquals("Mismatched updated factories name list", expected, manager.getSignatureFactoriesNameList());
+
+        List<NamedFactory<Signature>> factories = manager.getSignatureFactories();
+        assertEquals("Mismatched updated factories count", BuiltinSignatures.VALUES.size(), GenericUtils.size(factories));
+
+        for (NamedFactory<Signature> f : BuiltinSignatures.VALUES) {
+            assertTrue("Factory not set: " + f, factories.contains(f));
+        }
+    }
+
+    static class TestKexFactoryManager implements KexFactoryManager {
+        private List<NamedFactory<Compression>> compressions;
+        private List<NamedFactory<Cipher>> ciphers;
+        private List<NamedFactory<Mac>> macs;
+        private List<NamedFactory<Signature>> signatures;
+
+        TestKexFactoryManager() {
+            super();
+        }
+
+        @Override
+        public KeyPairProvider getKeyPairProvider() {
+            return null;
+        }
+
+        @Override
+        public void setKeyPairProvider(KeyPairProvider keyPairProvider) {
+            throw new UnsupportedOperationException("N/A");
+        }
+
+        @Override
+        public List<NamedFactory<Signature>> getSignatureFactories() {
+            return signatures;
+        }
+
+        @Override
+        public void setSignatureFactories(List<NamedFactory<Signature>> factories) {
+            signatures = factories;
+        }
+
+        @Override
+        public List<NamedFactory<KeyExchange>> getKeyExchangeFactories() {
+            return null;
+        }
+
+        @Override
+        public void setKeyExchangeFactories(List<NamedFactory<KeyExchange>> keyExchangeFactories) {
+            throw new UnsupportedOperationException("N/A");
+        }
+
+        @Override
+        public List<NamedFactory<Cipher>> getCipherFactories() {
+            return ciphers;
+        }
+
+        @Override
+        public void setCipherFactories(List<NamedFactory<Cipher>> cipherFactories) {
+            ciphers = cipherFactories;
+        }
+
+        @Override
+        public List<NamedFactory<Compression>> getCompressionFactories() {
+            return compressions;
+        }
+
+        @Override
+        public void setCompressionFactories(List<NamedFactory<Compression>> compressionFactories) {
+            compressions = compressionFactories;
+        }
+
+        @Override
+        public List<NamedFactory<Mac>> getMacFactories() {
+            return macs;
+        }
+
+        @Override
+        public void setMacFactories(List<NamedFactory<Mac>> macFactories) {
+            macs = macFactories;
+        }
+    }
+}