diff --git a/.gitignore b/.gitignore
index cad67e11..8db4d74d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,7 +23,9 @@
aclocal.m4
lt*.m4
*.cache
-config.*
+config.h*
+configure~
+config.status
configure
libtool
libtool.m4
@@ -54,6 +56,9 @@ examples/portfwd/portfwd
examples/sftpclient/wolfsftp
examples/scpclient/wolfscp
+# applications
+apps/wolfsshd/wolfsshd
+
# test output
tests/*.test
*.trs
diff --git a/Makefile.am b/Makefile.am
index 51838c46..a8759d4f 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -33,6 +33,7 @@ EXTRA_DIST+= LICENSING README.md ChangeLog.md
include src/include.am
include wolfssh/include.am
+include apps/wolfsshd/include.am
include examples/include.am
include tests/include.am
include keys/include.am
diff --git a/README.md b/README.md
index 23f9158e..4f2e46cf 100644
--- a/README.md
+++ b/README.md
@@ -53,6 +53,9 @@ to help with large file transfers. By default channels are set to handle
window size for new channels would be as follows
`./configure CPPFLAGS=-DDEFAULT_WINDOW_SZ=16384`
+For 32bit Linux platforms you can add support for files > 2GB by compling
+with `CFLAGS=-D_FILE_OFFSET_BITS=64`.
+
examples
--------
diff --git a/apps/wolfsshd/auth.c b/apps/wolfsshd/auth.c
new file mode 100644
index 00000000..3befdbeb
--- /dev/null
+++ b/apps/wolfsshd/auth.c
@@ -0,0 +1,920 @@
+/* auth.c
+ *
+ * Copyright (C) 2014-2022 wolfSSL Inc.
+ *
+ * This file is part of wolfSSH.
+ *
+ * wolfSSH is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSH is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wolfSSH. If not, see .
+ */
+
+#ifdef HAVE_CONFIG_H
+ #include
+#endif
+
+#ifdef WOLFSSH_SSHD
+
+#ifdef __linux__
+ #define _XOPEN_SOURCE
+ #define _GNU_SOURCE
+#endif
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#ifdef NO_INLINE
+ #include
+#else
+ #define WOLFSSH_MISC_INCLUDED
+ #include "src/misc.c"
+#endif
+
+#include "configuration.h"
+
+#ifndef _WIN32
+#include
+#include
+#include
+#endif
+
+#if !defined(_WIN32) && !(defined(__OSX__) || defined(__APPLE__))
+#include
+#define HAVE_SHADOW
+#endif
+
+struct WOLFSSHD_AUTH {
+ CallbackCheckUser CheckUserCb;
+ CallbackCheckPassword CheckPasswordCb;
+ CallbackCheckPublicKey CheckPublicKeyCb;
+ const WOLFSSHD_CONFIG* conf;
+ int gid;
+ int uid;
+ int attempts;
+ void* heap;
+};
+
+#ifndef WOLFSSHD_MAX_PASSWORD_ATTEMPTS
+ #define WOLFSSHD_MAX_PASSWORD_ATTEMPTS 3
+#endif
+
+#ifndef MAX_LEN_SZ
+ #define MAX_LINE_SZ 500
+#endif
+#ifndef MAX_PATH_SZ
+ #define MAX_PATH_SZ 80
+#endif
+
+#if 0
+/* this could potentially be useful in a deeply embeded future port */
+
+/* Map user names to passwords */
+/* Use arrays for username and p. The password or public key can
+ * be hashed and the hash stored here. Then I won't need the type. */
+struct USER_NODE {
+ byte type;
+ byte username[32];
+ word32 usernameSz;
+ byte fingerprint[WC_SHA256_DIGEST_SIZE];
+ struct USER_NODE* next;
+};
+
+
+/* Takes a users input and adds it to the list of accepted users
+ * 'value' can be a users password / public key / or certificate
+ * returns an updated list on success (i.e. 'new' -> 'list' -> ...) or NULL
+ * on failure
+ */
+USER_NODE* AddNewUser(USER_NODE* list, byte type, const byte* username,
+ word32 usernameSz, const byte* value, word32 valueSz)
+{
+ USER_NODE* map;
+
+ map = (USER_NODE*)WMALLOC(sizeof(USER_NODE), NULL, 0);
+ if (map != NULL) {
+ map->type = type;
+ if (usernameSz >= sizeof(map->username))
+ usernameSz = sizeof(map->username) - 1;
+ WMEMCPY(map->username, username, usernameSz + 1);
+ map->username[usernameSz] = 0;
+ map->usernameSz = usernameSz;
+
+ if (type != WOLFSSH_USERAUTH_NONE) {
+ wc_Sha256Hash(value, valueSz, map->fingerprint);
+ }
+
+ map->next = list;
+ }
+
+ return map;
+}
+#endif
+
+enum {
+ WSSHD_AUTH_FAILURE = 0,
+ WSSHD_AUTH_SUCCESS = 1
+};
+
+static int CheckAuthKeysLine(char* line, word32 lineSz, const byte* key,
+ word32 keySz)
+{
+ int ret = WSSHD_AUTH_SUCCESS;
+ char* type;
+ char* keyCandBase64; /* cand == candidate */
+ word32 keyCandBase64Sz;
+ byte* keyCand = NULL;
+ word32 keyCandSz;
+ char* last;
+ enum {
+ NUM_ALLOWED_TYPES = 5
+ };
+ static const char* allowedTypes[NUM_ALLOWED_TYPES] = {
+ "ssh-rsa",
+ "ssh-ed25519",
+ "ecdsa-sha2-nistp256",
+ "ecdsa-sha2-nistp384",
+ "ecdsa-sha2-nistp521"
+ };
+ int typeOk = 0;
+ int i;
+
+ if (line == NULL || lineSz == 0 || key == NULL || keySz == 0) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WSSHD_AUTH_SUCCESS) {
+ if ((type = WSTRTOK(line, " ", &last)) == NULL) {
+ ret = WS_FATAL_ERROR;
+ }
+ else if ((keyCandBase64 = WSTRTOK(NULL, " ", &last)) == NULL) {
+ ret = WS_FATAL_ERROR;
+ }
+ }
+ if (ret == WSSHD_AUTH_SUCCESS) {
+ for (i = 0; i < NUM_ALLOWED_TYPES; ++i) {
+ if (WSTRCMP(type, allowedTypes[i]) == 0) {
+ typeOk = 1;
+ break;
+ }
+ }
+ if (!typeOk) {
+ ret = WS_FATAL_ERROR;
+ }
+ }
+ if (ret == WSSHD_AUTH_SUCCESS) {
+ keyCandBase64Sz = (word32)XSTRLEN(keyCandBase64);
+ keyCandSz = (keyCandBase64Sz * 3 + 3) / 4;
+ keyCand = (byte*)WMALLOC(keyCandSz, NULL, DYNTYPE_BUFFER);
+ if (keyCand == NULL) {
+ ret = WS_MEMORY_E;
+ }
+ else {
+ if (Base64_Decode((byte*)keyCandBase64, keyCandBase64Sz, keyCand,
+ &keyCandSz) != 0) {
+ ret = WS_FATAL_ERROR;
+ }
+ }
+ }
+ if (ret == WSSHD_AUTH_SUCCESS) {
+ if (keyCandSz != keySz || WMEMCMP(key, keyCand, keySz) != 0) {
+ ret = WSSHD_AUTH_FAILURE;
+ }
+ }
+
+ if (keyCand != NULL) {
+ WFREE(keyCand, NULL, DYNTYPE_BUFFER);
+ }
+
+ return ret;
+}
+
+#ifndef _WIN32
+
+#ifdef WOLFSSH_USE_PAM
+static int CheckPasswordPAM(const char* usr, const byte* pw, word32 pwSz)
+{
+ (void)usr;
+ (void)pw;
+ (void)pwSz;
+ return 0;
+}
+#else
+
+#if 0
+static int ExtractSalt(char* hash, char** salt, int saltSz)
+{
+ int ret = WS_SUCCESS;
+ int idx = 0;
+ char* p;
+
+ if (hash == NULL || salt == NULL || *salt == NULL || saltSz <= 0) {
+ ret = WS_SUCCESS;
+ }
+
+ if (ret == 0) {
+ if (hash[idx] != '$') {
+ ret = WS_FATAL_ERROR;
+ }
+ else {
+ ++idx;
+ if (idx >= saltSz) {
+ ret = WS_BUFFER_E;
+ }
+ }
+ }
+ if (ret == 0) {
+ p = strstr(hash + idx, "$");
+ if (p == NULL) {
+ ret = -1;
+ }
+ else {
+ idx += (p - hash);
+ if (idx >= saltSz) {
+ ret = WS_BUFFER_E;
+ }
+ }
+ }
+ if (ret == 0) {
+ p = strstr(p + 1, "$");
+ if (p == NULL) {
+ ret = WS_FATAL_ERROR;
+ }
+ else {
+ idx += (p - (hash + idx) + 1);
+ if (idx >= saltSz) {
+ ret = WS_BUFFER_E;
+ }
+ }
+ }
+ if (ret == 0) {
+ memcpy(*salt, hash, idx);
+ (*salt)[idx] = 0;
+ }
+
+ return ret;
+}
+#endif
+
+#if defined(WOLFSSH_HAVE_LIBCRYPT) || defined(WOLFSSH_HAVE_LIBLOGIN)
+static int CheckPasswordHashUnix(const char* input, char* stored)
+{
+ int ret = WSSHD_AUTH_SUCCESS;
+ char* hashedInput;
+
+ if (input == NULL || stored == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WSSHD_AUTH_SUCCESS) {
+ hashedInput = crypt(input, stored);
+ if (hashedInput == NULL) {
+ ret = WS_FATAL_ERROR;
+ }
+ else {
+ if (WMEMCMP(hashedInput, stored, WSTRLEN(stored)) != 0) {
+ ret = WSSHD_AUTH_FAILURE;
+ }
+ }
+ }
+
+ return ret;
+}
+#endif /* WOLFSSH_HAVE_LIBCRYPT || WOLFSSH_HAVE_LIBLOGIN */
+
+static int CheckPasswordUnix(const char* usr, const byte* pw, word32 pwSz)
+{
+ int ret = WS_SUCCESS;
+ char* pwStr = NULL;
+ struct passwd* pwInfo;
+#ifdef HAVE_SHADOW
+ struct spwd* shadowInfo;
+#endif
+ /* The hash of the user's password stored on the system. */
+ char* storedHash;
+ char* storedHashCpy = NULL;
+
+ if (usr == NULL || pw == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WS_SUCCESS) {
+ pwStr = (char*)WMALLOC(pwSz + 1, NULL, DYNTYPE_STRING);
+ if (pwStr == NULL) {
+ ret = WS_MEMORY_E;
+ }
+ else {
+ XMEMCPY(pwStr, pw, pwSz);
+ pwStr[pwSz] = 0;
+ }
+ }
+
+ if (ret == WS_SUCCESS) {
+ pwInfo = getpwnam((const char*)usr);
+ if (pwInfo == NULL) {
+ /* user name not found on system */
+ ret = WS_FATAL_ERROR;
+ }
+ }
+
+ if (ret == WS_SUCCESS) {
+ #ifdef HAVE_SHADOW
+ if (pwInfo->pw_passwd[0] == 'x') {
+ #ifdef WOLFSSH_HAVE_LIBCRYPT
+ shadowInfo = getspnam((const char*)usr);
+ #else
+ shadowInfo = getspnam((char*)usr);
+ #endif
+ if (shadowInfo == NULL) {
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Error getting user password info");
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Possibly permisions level error?"
+ " i.e SSHD not ran as sudo");
+ ret = WS_FATAL_ERROR;
+ }
+ else {
+ storedHash = shadowInfo->sp_pwdp;
+ }
+ }
+ else
+ #endif
+ {
+ storedHash = pwInfo->pw_passwd;
+ }
+ }
+ if (ret == WS_SUCCESS) {
+ storedHashCpy = WSTRDUP(storedHash, NULL, DYNTYPE_STRING);
+ if (storedHash == NULL) {
+ ret = WS_MEMORY_E;
+ }
+ }
+
+ if (ret == WS_SUCCESS) {
+ #if defined(WOLFSSH_HAVE_LIBCRYPT) || defined(WOLFSSH_HAVE_LIBLOGIN)
+ ret = CheckPasswordHashUnix(pwStr, storedHashCpy);
+ #else
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] No compiled in password check");
+ ret = WS_NOT_COMPILED;
+ #endif
+ }
+
+ if (pwStr != NULL) {
+ WFREE(pwStr, NULL, DYNTYPE_STRING);
+ }
+ if (storedHashCpy != NULL) {
+ WFREE(storedHashCpy, NULL, DYNTYPE_STRING);
+ }
+
+ return ret;
+}
+#endif /* WOLFSSH_USE_PAM */
+#endif /* !_WIN32 */
+
+#ifndef _WIN32
+static int CheckUserUnix(const char* name) {
+ int ret = WSSHD_AUTH_FAILURE;
+ struct passwd* pwInfo;
+
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Unix check user");
+ errno = 0;
+ pwInfo = getpwnam(name);
+ if (pwInfo == NULL) {
+ if (errno != 0) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error calling getpwnam for user "
+ "%s.", name);
+ ret = WS_FATAL_ERROR;
+ }
+ }
+ else {
+ ret = WSSHD_AUTH_SUCCESS;
+ }
+
+ return ret;
+}
+
+static const char authKeysDefault[] = ".ssh/authorized_keys";
+static char authKeysPattern[MAX_PATH_SZ] = {0};
+
+void SetAuthKeysPattern(const char* pattern)
+{
+ if (pattern != NULL) {
+ WMEMSET(authKeysPattern, 0, sizeof(authKeysPattern));
+ WSTRNCPY(authKeysPattern, pattern, sizeof(authKeysPattern) - 1);
+ }
+}
+
+static int ResolveAuthKeysPath(const char* homeDir, char* resolved)
+{
+ int ret = WS_SUCCESS;
+ char* idx;
+ int homeDirSz;
+ const char* suffix = authKeysDefault;
+
+ if (homeDir == NULL || resolved == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WS_SUCCESS) {
+ if (*authKeysPattern != 0) {
+ /* TODO: token substitutions (e.g. %h) */
+ if (*authKeysPattern == '/') {
+ WSTRNCPY(resolved, authKeysPattern, MAX_PATH_SZ);
+ return WS_SUCCESS;
+ }
+ else {
+ suffix = authKeysPattern;
+ }
+ }
+ }
+
+ if (ret == WS_SUCCESS) {
+ idx = resolved;
+ homeDirSz = (int)XSTRLEN(homeDir);
+ if (homeDirSz + 1 + WSTRLEN(suffix) >= MAX_PATH_SZ) {
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Path for key file larger than max allowed");
+ ret = WS_FATAL_ERROR;
+ }
+
+ if (ret == WS_SUCCESS) {
+ XMEMCPY(idx, homeDir, homeDirSz);
+ idx += homeDirSz;
+ *(idx++) = '/';
+ /* Intentionally copying the null term from suffix. */
+ XMEMCPY(idx, suffix, WSTRLEN(suffix));
+ }
+ }
+
+ return ret;
+}
+
+static int CheckPublicKeyUnix(const char* name, const byte* key, word32 keySz)
+{
+ int ret = WSSHD_AUTH_SUCCESS;
+ int rc;
+ struct passwd* pwInfo;
+ char* authKeysFile = NULL;
+ XFILE f = NULL;
+ char* lineBuf = NULL;
+ char* current;
+ word32 currentSz;
+ int foundKey = 0;
+ char authKeysPath[MAX_PATH_SZ];
+
+ errno = 0;
+ pwInfo = getpwnam((const char*)name);
+ if (pwInfo == NULL) {
+ if (errno != 0) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error calling getpwnam for user "
+ "%s.", name);
+ }
+ ret = WS_FATAL_ERROR;
+ }
+
+ if (ret == WSSHD_AUTH_SUCCESS) {
+ WMEMSET(authKeysPath, 0, sizeof(authKeysPath));
+ rc = ResolveAuthKeysPath(pwInfo->pw_dir, authKeysPath);
+ if (rc != WS_SUCCESS) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Failed to resolve authorized keys"
+ " file path.");
+ ret = rc;
+ }
+ }
+ if (ret == WSSHD_AUTH_SUCCESS) {
+ f = XFOPEN(authKeysPath, "rb");
+ if (f == XBADFILE) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Unable to open %s",
+ authKeysPath);
+ ret = WS_BAD_FILE_E;
+ }
+ }
+ if (ret == WSSHD_AUTH_SUCCESS) {
+ lineBuf = (char*)WMALLOC(MAX_LINE_SZ, NULL, DYNTYPE_BUFFER);
+ if (lineBuf == NULL) {
+ ret = WS_MEMORY_E;
+ }
+ }
+ while (ret == WSSHD_AUTH_SUCCESS &&
+ (current = XFGETS(lineBuf, MAX_LINE_SZ, f)) != NULL) {
+ currentSz = (word32)XSTRLEN(current);
+
+ /* remove leading spaces */
+ while (currentSz > 0 && current[0] == ' ') {
+ currentSz = currentSz - 1;
+ current = current + 1;
+ }
+
+ if (currentSz <= 1) {
+ continue; /* empty line */
+ }
+
+ if (current[0] == '#') {
+ continue; /* commented out line */
+ }
+
+ rc = CheckAuthKeysLine(current, currentSz, key, keySz);
+ if (rc == WSSHD_AUTH_SUCCESS) {
+ foundKey = 1;
+ break;
+ }
+ else if (rc < 0) {
+ ret = rc;
+ break;
+ }
+ }
+ if (f != XBADFILE) {
+ XFCLOSE(f);
+ }
+
+ if (ret == WSSHD_AUTH_SUCCESS && !foundKey) {
+ ret = WSSHD_AUTH_FAILURE;
+ }
+
+ if (lineBuf != NULL) {
+ WFREE(lineBuf, NULL, DYNTYPE_BUFFER);
+ }
+ if (authKeysFile != NULL) {
+ WFREE(authKeysFile, NULL, DYNTYPE_STRING);
+ }
+
+ return ret;
+}
+#endif /* !_WIN32*/
+
+
+/* return WOLFSSH_USERAUTH_SUCCESS on success */
+static int DoCheckUser(const char* usr, WOLFSSHD_AUTH* auth)
+{
+ int ret = WOLFSSH_USERAUTH_FAILURE;
+ int rc;
+
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Checking user name %s", usr);
+ rc = auth->CheckUserCb(usr);
+ if (rc == WSSHD_AUTH_SUCCESS) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] User ok.");
+ ret = WOLFSSH_USERAUTH_SUCCESS;
+ }
+ else if (ret == WSSHD_AUTH_FAILURE) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] User %s doesn't exist.", usr);
+ ret = WOLFSSH_USERAUTH_INVALID_USER;
+ }
+ else {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error looking up user %s.", usr);
+ ret = WOLFSSH_USERAUTH_FAILURE;
+ }
+ return ret;
+}
+
+
+/* @TODO this will take in a pipe or equivalent to talk to a privileged thread
+ * rathar than having WOLFSSHD_AUTH directly with privilege separation */
+static int RequestAuthentication(const char* usr, int type, const byte* data,
+ int dataSz, WOLFSSHD_AUTH* auth)
+{
+ int ret;
+
+ if (auth == NULL)
+ return WOLFSSH_USERAUTH_FAILURE;
+
+ if (wolfSSHD_ConfigGetPermitRoot(auth->conf) == 0) {
+ if (XSTRCMP(usr, "root") == 0) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Login as root not permited");
+ return WOLFSSH_USERAUTH_FAILURE;
+ }
+ }
+
+ ret = DoCheckUser(usr, auth);
+ /* temporarily elevate permissions */
+ if (ret == WOLFSSH_USERAUTH_SUCCESS &&
+ wolfSSHD_AuthRaisePermissions(auth) != WS_SUCCESS) {
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Failure to raise permissions for auth");
+ ret = WOLFSSH_USERAUTH_FAILURE;
+ }
+
+ if (ret == WOLFSSH_USERAUTH_SUCCESS && type == WOLFSSH_USERAUTH_PASSWORD) {
+ int rc;
+
+ if (wolfSSHD_ConfigGetPwAuth(auth->conf) != 1) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Password authentication not "
+ "allowed by configuration!");
+ ret = WOLFSSH_USERAUTH_FAILURE;
+ }
+ /* Check if password is valid for this user. */
+ /* first handle empty password cases */
+ else if (dataSz == 0 && wolfSSHD_ConfigGetPermitEmptyPw(auth->conf)
+ != 1) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Empty passwords not allowed by "
+ "configuration!");
+ ret = WOLFSSH_USERAUTH_FAILURE;
+ }
+ else {
+ rc = auth->CheckPasswordCb(usr, data, dataSz);
+ if (rc == WSSHD_AUTH_SUCCESS) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Password ok.");
+ }
+ else if (rc == WSSHD_AUTH_FAILURE) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Password incorrect.");
+ ret = WOLFSSH_USERAUTH_INVALID_PASSWORD;
+
+ auth->attempts--;
+ if (auth->attempts == 0) {
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Too many bad password attempts!");
+ ret = WOLFSSH_USERAUTH_REJECTED;
+ }
+ }
+ else {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error checking password.");
+ ret = WOLFSSH_USERAUTH_FAILURE;
+ }
+ }
+ }
+
+
+ if (ret == WOLFSSH_USERAUTH_SUCCESS && type == WOLFSSH_USERAUTH_PUBLICKEY) {
+ int rc;
+
+ rc = auth->CheckPublicKeyCb(usr, data, dataSz);
+ if (rc == WSSHD_AUTH_SUCCESS) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Public key ok.");
+ ret = WOLFSSH_USERAUTH_SUCCESS;
+ }
+ else if (rc == WSSHD_AUTH_FAILURE) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Public key not authorized.");
+ ret = WOLFSSH_USERAUTH_INVALID_PUBLICKEY;
+ }
+ else {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error checking public key.");
+ ret = WOLFSSH_USERAUTH_FAILURE;
+ }
+ }
+
+
+ if (wolfSSHD_AuthReducePermissions(auth) != WS_SUCCESS) {
+ /* stop everything if not able to reduce permissions level */
+ exit(1);
+ }
+ return ret;
+}
+
+
+/* return WOLFSSH_USERAUTH_SUCCESS on success */
+int DefaultUserAuth(byte authType, WS_UserAuthData* authData, void* ctx)
+{
+ int ret = WOLFSSH_USERAUTH_SUCCESS;
+ WOLFSSHD_AUTH* auth;
+
+ if (ctx == NULL) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] No auth callbacks passed in");
+ return WOLFSSH_USERAUTH_FAILURE;
+ }
+ else {
+ auth = (WOLFSSHD_AUTH*)ctx;
+ if (auth->CheckUserCb == NULL) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] No way to check the user is set");
+ return WOLFSSH_USERAUTH_FAILURE;
+ }
+ }
+
+ if (authData == NULL) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] No authData passed in");
+ return WOLFSSH_USERAUTH_FAILURE;
+ }
+
+ if (authType != WOLFSSH_USERAUTH_PASSWORD &&
+#ifdef WOLFSSH_ALLOW_USERAUTH_NONE
+ authType != WOLFSSH_USERAUTH_NONE &&
+#endif
+ authType != WOLFSSH_USERAUTH_PUBLICKEY) {
+
+ ret = WOLFSSH_USERAUTH_INVALID_AUTHTYPE;
+ }
+
+ /* call to possibly privilaged authentecator for password check */
+ if (ret == WOLFSSH_USERAUTH_SUCCESS &&
+ authData->type == WOLFSSH_USERAUTH_PASSWORD) {
+ ret = RequestAuthentication((const char*)authData->username,
+ authData->type,
+ authData->sf.password.password,
+ authData->sf.password.passwordSz, auth);
+ }
+
+ /* call to possibly privilaged authentecator for public key check */
+ if (ret == WOLFSSH_USERAUTH_SUCCESS &&
+ authData->type == WOLFSSH_USERAUTH_PUBLICKEY) {
+ ret = RequestAuthentication((const char*)authData->username,
+ authData->type,
+ authData->sf.publicKey.publicKey,
+ authData->sf.publicKey.publicKeySz, auth);
+ }
+
+ return ret;
+}
+
+
+static int SetDefaultUserCheck(WOLFSSHD_AUTH* auth)
+{
+ int ret = WS_NOT_COMPILED;
+
+#ifdef _WIN32
+ /* TODO: Implement for Windows. */
+#else
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Setting default Unix user name check");
+ auth->CheckUserCb = CheckUserUnix;
+ ret = WS_SUCCESS;
+#endif
+
+ return ret;
+}
+
+
+static int SetDefaultPasswordCheck(WOLFSSHD_AUTH* auth)
+{
+ int ret = WS_NOT_COMPILED;
+
+#ifdef _WIN32
+ /* TODO: Add CheckPasswordWin. */
+#elif defined(WOLFSSH_USE_PAM)
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Setting PAM password check");
+ auth->CheckPasswordCb = CheckPasswordPAM;
+ ret = WS_SUCCESS;
+#else
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Setting Unix password check");
+ auth->CheckPasswordCb = CheckPasswordUnix;
+ ret = WS_SUCCESS;
+#endif
+ return ret;
+}
+
+
+static int SetDefaultPublicKeyCheck(WOLFSSHD_AUTH* auth)
+{
+ int ret = WS_NOT_COMPILED;
+
+#ifdef _WIN32
+ /* TODO: Implement for Windows. */
+#else
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Setting Unix public key check");
+ auth->CheckPublicKeyCb = CheckPublicKeyUnix;
+ ret = WS_SUCCESS;
+#endif
+ return ret;
+}
+
+
+/* Sets the default functions to be used for authentication of peer.
+ * Later the default functions could be overriden if needed.
+ * returns a newly created WOLFSSHD_AUTH struct success */
+WOLFSSHD_AUTH* wolfSSHD_AuthCreateUser(void* heap, const WOLFSSHD_CONFIG* conf)
+{
+ WOLFSSHD_AUTH* auth;
+
+ auth = (WOLFSSHD_AUTH*)WMALLOC(sizeof(WOLFSSHD_AUTH), heap, DYNTYPE_SSHD);
+ if (auth != NULL) {
+ int ret;
+ struct passwd* pwInfo;
+ const char* usr = "sshd";
+
+ auth->heap = heap;
+ auth->conf = conf;
+ auth->attempts = WOLFSSHD_MAX_PASSWORD_ATTEMPTS;
+
+ /* set the default user checking based on build */
+ ret = SetDefaultUserCheck(auth);
+ if (ret != WS_SUCCESS) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error setting default user check.");
+ }
+
+ /* set the default password checking based on build */
+ if (ret == WS_SUCCESS) {
+ ret = SetDefaultPasswordCheck(auth);
+ if (ret != WS_SUCCESS) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error setting default "
+ "password check.");
+ }
+ }
+
+ /* set the default public key checking based on build */
+ if (ret == WS_SUCCESS) {
+ ret = SetDefaultPublicKeyCheck(auth);
+ if (ret != WS_SUCCESS) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error setting default "
+ "public key check.");
+ }
+ }
+
+ if (ret == WS_SUCCESS) {
+ pwInfo = getpwnam(usr);
+ if (pwInfo == NULL) {
+ /* user name not found on system */
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] No sshd user found to use");
+ ret = WS_FATAL_ERROR;
+ }
+ }
+
+ if (ret == WS_SUCCESS) {
+ auth->gid = pwInfo->pw_gid;
+ auth->uid = pwInfo->pw_uid;
+ }
+
+ /* error case in setting one of the default callbacks */
+ if (ret != WS_SUCCESS) {
+ (void)wolfSSHD_AuthFreeUser(auth);
+ auth = NULL;
+ }
+ }
+
+
+ return auth;
+}
+
+
+/* returns WS_SUCCESS on success */
+int wolfSSHD_AuthFreeUser(WOLFSSHD_AUTH* auth)
+{
+ if (auth != NULL) {
+ WFREE(auth, auth->heap, DYNTYPE_SSHD);
+ }
+ return WS_SUCCESS;
+}
+
+
+/* return WS_SUCCESS on success */
+int wolfSSHD_AuthRaisePermissions(WOLFSSHD_AUTH* auth)
+{
+ int ret = 0;
+
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Attempting to raise permissions level");
+ if (auth) {
+ if (setegid(0) != 0) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error rasing gid");
+ ret = WS_FATAL_ERROR;
+ }
+
+ if (seteuid(0) != 0) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error rasing uid");
+ ret = WS_FATAL_ERROR;
+ }
+ }
+ else {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ return ret;
+}
+
+
+/* return WS_SUCCESS on success */
+int wolfSSHD_AuthReducePermissions(WOLFSSHD_AUTH* auth)
+{
+ byte flag = 0;
+ int ret = WS_SUCCESS;
+
+ flag = wolfSSHD_ConfigGetPrivilegeSeparation(auth->conf);
+ if (flag == WOLFSSHD_PRIV_SEPARAT || flag == WOLFSSHD_PRIV_SANDBOX) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Lowering permissions level");
+ if (auth) {
+ if (setegid(auth->gid) != 0) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error setting sshd gid");
+ ret = WS_FATAL_ERROR;
+ }
+
+ if (seteuid(auth->uid) != 0) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error setting sshd uid");
+ ret = WS_FATAL_ERROR;
+ }
+ }
+ else {
+ ret = WS_BAD_ARGUMENT;
+ }
+ }
+ return ret;
+}
+
+/* return the time in seconds for grace timeout period */
+long wolfSSHD_AuthGetGraceTime(const WOLFSSHD_AUTH* auth)
+{
+ long ret = WS_BAD_ARGUMENT;
+
+ if (auth != NULL && auth->conf != NULL) {
+ ret = wolfSSHD_ConfigGetGraceTime(auth->conf);
+ }
+
+ return ret;
+}
+#endif /* WOLFSSH_SSHD */
diff --git a/apps/wolfsshd/auth.h b/apps/wolfsshd/auth.h
new file mode 100644
index 00000000..01e41106
--- /dev/null
+++ b/apps/wolfsshd/auth.h
@@ -0,0 +1,62 @@
+/* auth.h
+ *
+ * Copyright (C) 2014-2022 wolfSSL Inc.
+ *
+ * This file is part of wolfSSH.
+ *
+ * wolfSSH is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSH is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wolfSSH. If not, see .
+ */
+
+#ifndef WOLFAUTH_H
+#define WOLFAUTH_H
+
+#if 0
+typedef struct USER_NODE USER_NODE;
+
+USER_NODE* AddNewUser(USER_NODE* list, byte type, const byte* username,
+ word32 usernameSz, const byte* value, word32 valueSz);
+#endif
+
+void SetAuthKeysPattern(const char* pattern);
+int DefaultUserAuth(byte authType, WS_UserAuthData* authData, void* ctx);
+
+typedef struct WOLFSSHD_AUTH WOLFSSHD_AUTH;
+
+/*
+ * Returns WSSHD_AUTH_SUCCESS if user found, WSSHD_AUTH_FAILURE if user not
+ * found, and negative values if an error occurs during checking.
+ */
+typedef int (*CallbackCheckUser)(const char* usr);
+
+
+/*
+ * Returns WSSHD_AUTH_SUCCESS if user found, WSSHD_AUTH_FAILURE if user not
+ * found, and negative values if an error occurs during checking.
+ */
+typedef int (*CallbackCheckPassword)(const char* usr, const byte* psw,
+ word32 pswSz);
+
+/*
+ * Returns WSSHD_AUTH_SUCCESS if public key ok, WSSHD_AUTH_FAILURE if key not
+ * ok, and negative values if an error occurs during checking.
+ */
+typedef int (*CallbackCheckPublicKey)(const char* usr, const byte* key,
+ word32 keySz);
+
+WOLFSSHD_AUTH* wolfSSHD_AuthCreateUser(void* heap, const WOLFSSHD_CONFIG* conf);
+int wolfSSHD_AuthFreeUser(WOLFSSHD_AUTH* auth);
+int wolfSSHD_AuthReducePermissions(WOLFSSHD_AUTH* auth);
+int wolfSSHD_AuthRaisePermissions(WOLFSSHD_AUTH* auth);
+long wolfSSHD_AuthGetGraceTime(const WOLFSSHD_AUTH* auth);
+#endif /* WOLFAUTH_H */
diff --git a/apps/wolfsshd/configuration.c b/apps/wolfsshd/configuration.c
new file mode 100644
index 00000000..695f40b2
--- /dev/null
+++ b/apps/wolfsshd/configuration.c
@@ -0,0 +1,909 @@
+/* configuration.c
+ *
+ * Copyright (C) 2014-2022 wolfSSL Inc.
+ *
+ * This file is part of wolfSSH.
+ *
+ * wolfSSH is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSH is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wolfSSH. If not, see .
+ */
+
+#ifdef HAVE_CONFIG_H
+ #include
+#endif
+
+#ifdef WOLFSSH_SSHD
+/* functions for parsing out options from a config file and for handling loading
+ * key/certs using the env. filesystem */
+
+#ifdef WOLFSSHD_UNIT_TEST
+#define WOLFSSHD_STATIC
+#else
+#define WOLFSSHD_STATIC static
+#endif
+
+#include
+#include
+#include
+#include
+#include
+
+#ifdef NO_INLINE
+ #include
+#else
+ #define WOLFSSH_MISC_INCLUDED
+ #include "src/misc.c"
+#endif
+
+#include "configuration.h"
+
+struct WOLFSSHD_CONFIG {
+ void* heap;
+ char* banner;
+ char* chrootDir;
+ char* ciphers;
+ char* hostKeyFile;
+ char* hostKeyAlgos;
+ char* kekAlgos;
+ char* listenAddress;
+ char* authKeysFile;
+ long loginTimer;
+ word16 port;
+ byte usePrivilegeSeparation;
+ byte passwordAuth:1;
+ byte pubKeyAuth:1;
+ byte permitRootLogin:1;
+ byte permitEmptyPasswords:1;
+};
+
+
+/* convert a string into seconds, handles if 'm' for minutes follows the string
+ * number, i.e. 2m
+ * Returns the value on success and negative value on failure */
+static long GetConfigInt(const char* in, int inSz, int isTime, void* heap)
+{
+ long ret = 0;
+ int mult = 1; /* multiplier */
+ int sz = inSz;
+
+ /* check for multipliers */
+ if (isTime) {
+ if (in[sz - 1] == 'm') {
+ sz--;
+ mult = 60;
+ }
+ if (in[sz - 1] == 'h') {
+ sz--;
+ mult = 60*60;
+ }
+ }
+
+ if (ret == 0) {
+ char* num = (char*)WMALLOC(sz + 1, heap, DYNTYPE_SSHD);
+ if (num == NULL) {
+ ret = WS_MEMORY_E;
+ }
+ else {
+ WMEMCPY(num, in, sz);
+ num[sz] = '\0';
+ ret = atol(num);
+ if (ret == 0 && WSTRCMP(in, "0") != 0) {
+ ret = WS_BAD_ARGUMENT;
+ }
+ else if (ret > 0) {
+ ret = ret * mult;
+ }
+ WFREE(num, heap, DYNTYPE_SSHD);
+ }
+ }
+
+ return ret;
+}
+
+/* returns WS_SUCCESS on success */
+static int CreateString(char** out, const char* in, int inSz, void* heap)
+{
+ int ret = WS_SUCCESS;
+ int idx = 0;
+
+ /* remove leading white spaces */
+ while (idx < inSz && in[idx] == ' ') idx++;
+
+ if (idx == inSz) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ /* malloc new string and set it */
+ if (ret == WS_SUCCESS) {
+ *out = (char*)WMALLOC((inSz - idx) + 1, heap, DYNTYPE_SSHD);
+ if (*out == NULL) {
+ ret = WS_MEMORY_E;
+ }
+ else {
+ XMEMCPY(*out, in + idx, inSz - idx);
+ *(*out + (inSz - idx)) = '\0';
+ }
+ }
+
+ return ret;
+}
+
+static void FreeString(char** in, void* heap)
+{
+ if (*in != NULL) {
+ WFREE(*in, heap, DYNTYPE_SSHD);
+ *in = NULL;
+ }
+ (void)heap;
+}
+
+
+/* returns a new WOLFSSHD_CONFIG on success and NULL on failure */
+WOLFSSHD_CONFIG* wolfSSHD_ConfigNew(void* heap)
+{
+ WOLFSSHD_CONFIG* ret;
+
+ ret = (WOLFSSHD_CONFIG*)WMALLOC(sizeof(WOLFSSHD_CONFIG), heap,
+ DYNTYPE_SSHD);
+ if (ret == NULL) {
+ fprintf(stderr, "Issue malloc'ing config structure for sshd\n");
+ }
+ else {
+ WMEMSET(ret, 0, sizeof(WOLFSSHD_CONFIG));
+
+ /* default values */
+ ret->port = 22;
+ ret->passwordAuth = 1;
+ }
+ return ret;
+
+}
+
+void wolfSSHD_ConfigFree(WOLFSSHD_CONFIG* conf)
+{
+ void* heap;
+
+ if (conf != NULL) {
+ heap = conf->heap;
+
+ FreeString(&conf->authKeysFile, heap);
+ FreeString(&conf->hostKeyFile, heap);
+
+ WFREE(conf, heap, DYNTYPE_SSHD);
+ }
+}
+
+#define MAX_LINE_SIZE 160
+
+typedef struct {
+ int tag;
+ const char* name;
+} CONFIG_OPTION;
+
+enum {
+ OPT_AUTH_KEYS_FILE = 0,
+ OPT_PRIV_SEP = 1,
+ OPT_PERMIT_EMPTY_PW = 2,
+ OPT_SUBSYSTEM = 3,
+ OPT_CHALLENGE_RESPONSE_AUTH = 4,
+ OPT_USE_PAM = 5,
+ OPT_X11_FORWARDING = 6,
+ OPT_PRINT_MOTD = 7,
+ OPT_ACCEPT_ENV = 8,
+ OPT_PROTOCOL = 9,
+ OPT_LOGIN_GRACE_TIME = 10,
+ OPT_HOST_KEY = 11,
+ OPT_PASSWORD_AUTH = 12,
+ OPT_PORT = 13,
+ OPT_PERMIT_ROOT = 14,
+ OPT_USE_DNS = 15,
+ OPT_INCLUDE = 16
+};
+enum {
+ NUM_OPTIONS = 17
+};
+
+static const CONFIG_OPTION options[NUM_OPTIONS] = {
+ {OPT_AUTH_KEYS_FILE, "AuthorizedKeysFile"},
+ {OPT_PRIV_SEP, "UsePrivilegeSeparation"},
+ {OPT_PERMIT_EMPTY_PW, "PermitEmptyPasswords"},
+ {OPT_SUBSYSTEM, "Subsystem"},
+ {OPT_CHALLENGE_RESPONSE_AUTH, "ChallengeResponseAuthentication"},
+ {OPT_USE_PAM, "UsePAM"},
+ {OPT_X11_FORWARDING, "X11Forwarding"},
+ {OPT_PRINT_MOTD, "PrintMotd"},
+ {OPT_ACCEPT_ENV, "AcceptEnv"},
+ {OPT_PROTOCOL, "Protocol"},
+ {OPT_LOGIN_GRACE_TIME, "LoginGraceTime"},
+ {OPT_HOST_KEY, "HostKey"},
+ {OPT_PASSWORD_AUTH, "PasswordAuthentication"},
+ {OPT_PORT, "Port"},
+ {OPT_PERMIT_ROOT, "PermitRootLogin"},
+ {OPT_USE_DNS, "UseDNS"},
+ {OPT_INCLUDE, "Include"}
+};
+
+/* returns WS_SUCCESS on success */
+static int HandlePrivSep(WOLFSSHD_CONFIG* conf, const char* value)
+{
+ int ret = WS_SUCCESS;
+
+ if (conf == NULL || value == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WS_SUCCESS) {
+ if (WSTRCMP(value, "sandbox") == 0) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Sandbox privilege separation");
+ conf->usePrivilegeSeparation = WOLFSSHD_PRIV_SANDBOX;
+ }
+ else if (WSTRCMP(value, "yes") == 0) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Privilege separation enabled");
+ conf->usePrivilegeSeparation = WOLFSSHD_PRIV_SEPARAT;
+ }
+ else if (WSTRCMP(value, "no") == 0) {
+ wolfSSH_Log(WS_LOG_INFO,
+ "[SSHD] Turning off privilege separation!");
+ conf->usePrivilegeSeparation = WOLFSSHD_PRIV_OFF;
+ }
+ else {
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Unknown/supported privilege separation!");
+ ret = WS_BAD_ARGUMENT;
+ }
+ }
+
+ return ret;
+}
+
+/* returns WS_SUCCESS on success */
+static int HandleLoginGraceTime(WOLFSSHD_CONFIG* conf, const char* value)
+{
+ int ret = WS_SUCCESS;
+ long num;
+
+ if (conf == NULL || value == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WS_SUCCESS) {
+ num = GetConfigInt(value, (int)XSTRLEN(value), 1, conf->heap);
+ if (num < 0) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Issue getting login grace "
+ "time");
+ ret = (int)num;
+ }
+ else {
+ conf->loginTimer = num;
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Setting login grace time to "
+ "%ld", num);
+ }
+ }
+
+ return ret;
+}
+
+/* returns WS_SUCCESS on success */
+static int HandlePermitEmptyPw(WOLFSSHD_CONFIG* conf, const char* value)
+{
+ int ret = WS_SUCCESS;
+
+ if (conf == NULL || value == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WS_SUCCESS) {
+ if (WSTRCMP(value, "no") == 0) {
+ conf->permitEmptyPasswords = 0;
+ }
+ else if (WSTRCMP(value, "yes") == 0) {
+ conf->permitEmptyPasswords = 1;
+ }
+ else {
+ ret = WS_BAD_ARGUMENT;
+ }
+ }
+
+ return ret;
+}
+
+/* returns WS_SUCCESS on success */
+static int HandlePermitRoot(WOLFSSHD_CONFIG* conf, const char* value)
+{
+ int ret = WS_SUCCESS;
+
+ if (conf == NULL || value == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WS_SUCCESS) {
+ if (WSTRCMP(value, "no") == 0) {
+ conf->permitRootLogin = 0;
+ }
+ else if (WSTRCMP(value, "yes") == 0) {
+ conf->permitRootLogin = 1;
+ }
+ else {
+ ret = WS_BAD_ARGUMENT;
+ }
+ }
+
+ return ret;
+}
+
+/* returns WS_SUCCESS on success */
+static int HandlePwAuth(WOLFSSHD_CONFIG* conf, const char* value)
+{
+ int ret = WS_SUCCESS;
+
+ if (conf == NULL || value == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WS_SUCCESS) {
+ if (WSTRCMP(value, "no") == 0) {
+ conf->passwordAuth = 0;
+ }
+ else if (WSTRCMP(value, "yes") == 0) {
+ conf->passwordAuth = 1;
+ }
+ else {
+ ret = WS_BAD_ARGUMENT;
+ }
+ }
+
+ return ret;
+}
+
+#define WOLFSSH_PROTOCOL_VERSION 2
+
+/* returns WS_SUCCESS on success */
+static int HandleProtocol(WOLFSSHD_CONFIG* conf, const char* value)
+{
+ int ret = WS_SUCCESS;
+ long portInt;
+
+ if (conf == NULL || value == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WS_SUCCESS) {
+ portInt = GetConfigInt(value, (int)WSTRLEN(value), 0, conf->heap);
+ if (portInt <= 0) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Invalid protocol number: %s.",
+ value);
+ ret = WS_BAD_ARGUMENT;
+ }
+ else {
+ if (portInt != WOLFSSH_PROTOCOL_VERSION) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Protocol number %ld not "
+ "supported.", portInt);
+ ret = WS_BAD_ARGUMENT;
+ }
+ }
+ }
+
+ return ret;
+}
+
+/* returns WS_SUCCESS on success */
+static int HandlePort(WOLFSSHD_CONFIG* conf, const char* value)
+{
+ int ret = WS_SUCCESS;
+ long portInt;
+
+ if (conf == NULL || value == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WS_SUCCESS) {
+ portInt = GetConfigInt(value, (int)WSTRLEN(value), 0, conf->heap);
+ if (portInt <= 0) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Invalid port number: %s.",
+ value);
+ ret = WS_BAD_ARGUMENT;
+ }
+ else {
+ if (portInt <= (word16)-1) {
+ conf->port = (word16)portInt;
+ }
+ else {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Port number %ld too big.",
+ portInt);
+ ret = WS_BAD_ARGUMENT;
+ }
+ }
+ }
+
+ return ret;
+}
+
+static int HandleInclude(WOLFSSHD_CONFIG *conf, const char *value)
+{
+ const char *ptr;
+ const char *ptr2;
+ const char *postfix = NULL;
+ const char *prefix = NULL;
+ int prefixLen = 0;
+ int found = 0;
+
+ /* No value, nothing to do */
+ if (!value || value[0] == '\0') {
+ return WS_BAD_ARGUMENT;
+ }
+
+ /* Ignore trailing whitespace */
+ ptr = value + WSTRLEN(value) - 1;
+ while (ptr != value) {
+ if (!WISSPACE(*ptr)) {
+ ptr--;
+ }
+ else {
+ break;
+ }
+ }
+
+ /* Find wildcards */
+ ptr2 = ptr;
+ while (ptr2 != value) {
+ if (*ptr2 == '*') {
+ /* Wildcard found */
+ found = 1;
+ if (ptr != ptr2) {
+ postfix = ptr2 + 1;
+ }
+ break;
+ }
+ if (*ptr2 == '/') {
+ /* Found slash before wildcard directory-wildcards not supported */
+ break;
+ }
+ ptr2--;
+ }
+ ptr = ptr2;
+
+ /* Use wildcard */
+ if (found) {
+#ifdef __unix__
+ int ret;
+ struct dirent *dir;
+ DIR *d;
+ char *path;
+ char *filepath = WMALLOC(PATH_MAX, NULL, 0);
+
+ /* Back find the full path */
+ while (ptr2 != value) {
+ if (*ptr2 == '/') {
+ break;
+ }
+ ptr2--;
+ }
+
+ if (ptr2 != value) {
+ path = WMALLOC(ptr2 - value + 1, NULL, 0);
+ memcpy(path, value, ptr2 - value);
+ path[ptr2 - value] = '\0';
+ prefix = ptr2 + 1;
+ prefixLen = (int)(ptr - ptr2 - 1);
+ } else {
+ path = WMALLOC(2, NULL, 0);
+ memcpy(path, ".", 1);
+ path[1] = '\0';
+ prefix = value;
+ prefixLen = (int)(ptr - value);
+ }
+
+ d = opendir(path);
+ if (d) {
+ while ((dir = readdir(d)) != NULL) {
+ if (dir->d_type == DT_DIR) {
+ /* Skip sub-directories */
+ continue;
+ }
+ else {
+ /* Check if filename prefix matches */
+ if (prefixLen > 0) {
+ if ((int)WSTRLEN(dir->d_name) <= prefixLen) {
+ continue;
+ }
+ if (WSTRNCMP(dir->d_name, prefix, prefixLen) != 0) {
+ continue;
+ }
+ }
+ if (postfix) {
+ /* Skip if file is too short */
+ if (WSTRLEN(dir->d_name) <= WSTRLEN(postfix)) {
+ continue;
+ }
+ if (WSTRNCMP(dir->d_name + WSTRLEN(dir->d_name) -
+ WSTRLEN(postfix), postfix, WSTRLEN(postfix))
+ == 0) {
+ snprintf(filepath, PATH_MAX, "%s/%s", path,
+ dir->d_name);
+ }
+ else {
+ /* Not a match */
+ continue;
+ }
+ }
+ else {
+ snprintf(filepath, PATH_MAX, "%s/%s", path,
+ dir->d_name);
+ }
+ ret = wolfSSHD_ConfigLoad(conf, filepath);
+ if (ret != WS_SUCCESS) {
+ return ret;
+ }
+ }
+ }
+ }
+ else {
+ /* Bad directory */
+ WFREE(filepath, NULL, 0);
+ return WS_BAD_ARGUMENT;
+ }
+ WFREE(filepath, NULL, 0);
+#else
+ (void)postfix;
+ (void)prefixLen;
+ (void)prefix;
+ /* Don't support wildcards here */
+ return WS_BAD_ARGUMENT;
+#endif
+ }
+ else {
+ return wolfSSHD_ConfigLoad(conf, value);
+ }
+ return WS_SUCCESS;
+}
+
+/* returns WS_SUCCESS on success */
+static int HandleConfigOption(WOLFSSHD_CONFIG* conf, int opt, const char* value)
+{
+ int ret = WS_BAD_ARGUMENT;
+
+ switch (opt) {
+ case OPT_AUTH_KEYS_FILE:
+ ret = wolfSSHD_ConfigSetAuthKeysFile(conf, value);
+ break;
+ case OPT_PRIV_SEP:
+ ret = HandlePrivSep(conf, value);
+ break;
+ case OPT_PERMIT_EMPTY_PW:
+ ret = HandlePermitEmptyPw(conf, value);
+ break;
+ case OPT_SUBSYSTEM:
+ /* TODO */
+ ret = WS_SUCCESS;
+ break;
+ case OPT_CHALLENGE_RESPONSE_AUTH:
+ /* TODO */
+ ret = WS_SUCCESS;
+ break;
+ case OPT_USE_PAM:
+ /* TODO */
+ ret = WS_SUCCESS;
+ break;
+ case OPT_X11_FORWARDING:
+ /* TODO */
+ ret = WS_SUCCESS;
+ break;
+ case OPT_PRINT_MOTD:
+ /* TODO */
+ ret = WS_SUCCESS;
+ break;
+ case OPT_ACCEPT_ENV:
+ /* TODO */
+ ret = WS_SUCCESS;
+ break;
+ case OPT_PROTOCOL:
+ /* TODO */
+ ret = HandleProtocol(conf, value);
+ break;
+ case OPT_LOGIN_GRACE_TIME:
+ ret = HandleLoginGraceTime(conf, value);
+ break;
+ case OPT_HOST_KEY:
+ /* TODO: Add logic to check if file exists? */
+ ret = wolfSSHD_ConfigSetHostKeyFile(conf, value);
+ break;
+ case OPT_PASSWORD_AUTH:
+ ret = HandlePwAuth(conf, value);
+ break;
+ case OPT_PORT:
+ ret = HandlePort(conf, value);
+ break;
+ case OPT_PERMIT_ROOT:
+ ret = HandlePermitRoot(conf, value);
+ break;
+ case OPT_USE_DNS:
+ /* TODO */
+ ret = WS_SUCCESS;
+ break;
+ case OPT_INCLUDE:
+ ret = HandleInclude(conf, value);
+ break;
+ default:
+ break;
+ }
+
+ return ret;
+}
+
+/* helper function to count white spaces, returns the number of white spaces on
+ * success */
+static int CountWhitespace(const char* in, int inSz, byte inv)
+{
+ int i = 0;
+
+ if (in != NULL) {
+ for (; i < inSz; ++i) {
+ if (inv) {
+ if (WISSPACE(in[i])) {
+ break;
+ }
+ }
+ else {
+ if (!WISSPACE(in[i])) {
+ break;
+ }
+ }
+ }
+ }
+
+ return i;
+}
+
+/* returns WS_SUCCESS on success
+ * Fails if any option is found that is unknown/unsupported
+ */
+WOLFSSHD_STATIC int ParseConfigLine(WOLFSSHD_CONFIG* conf, const char* l,
+ int lSz)
+{
+ int ret = WS_BAD_ARGUMENT;
+ int sz = 0;
+ char tmp[MAX_FILENAME_SZ];
+ int idx;
+ const CONFIG_OPTION* found = NULL;
+
+ for (idx = 0; idx < NUM_OPTIONS; ++idx) {
+ sz = (int)WSTRLEN(options[idx].name);
+ if (lSz >= sz && WSTRNCMP(l, options[idx].name, sz) == 0) {
+ found = &options[idx];
+ break;
+ }
+ }
+
+ if (found != NULL) {
+ /*
+ * Count leading and trailing whitespace. Use that information to cut
+ * out just the string itself when creating tmp.
+ */
+ idx = sz;
+ idx += CountWhitespace(l + idx, lSz - sz, 0);
+ sz = CountWhitespace(l + idx, lSz - sz, 1);
+ if (sz >= MAX_FILENAME_SZ) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Filename too long.");
+ ret = WS_FATAL_ERROR;
+ }
+ else {
+ WMEMCPY(tmp, l + idx, sz);
+ tmp[sz] = 0;
+ ret = HandleConfigOption(conf, found->tag, tmp);
+ }
+ }
+ else {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Error parsing config line.");
+ ret = WS_FATAL_ERROR;
+ }
+
+ return ret;
+}
+
+
+/* parses and loads in the given configuration file 'filename'
+ * returns WS_SUCCESS on success
+ */
+int wolfSSHD_ConfigLoad(WOLFSSHD_CONFIG* conf, const char* filename)
+{
+ XFILE f;
+ int ret = WS_SUCCESS;
+ char buf[MAX_LINE_SIZE];
+ const char* current;
+
+ if (conf == NULL || filename == NULL)
+ return BAD_FUNC_ARG;
+
+ f = XFOPEN(filename, "rb");
+ if (f == XBADFILE) {
+ wolfSSH_Log(WS_LOG_ERROR, "Unable to open SSHD config file %s\n",
+ filename);
+ return BAD_FUNC_ARG;
+ }
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] parsing config file %s", filename);
+
+ while ((current = XFGETS(buf, MAX_LINE_SIZE, f)) != NULL) {
+ int currentSz = (int)XSTRLEN(current);
+
+ /* remove leading spaces */
+ while (currentSz > 0 && current[0] == ' ') {
+ currentSz = currentSz - 1;
+ current = current + 1;
+ }
+
+ if (currentSz <= 1) {
+ continue; /* empty line */
+ }
+
+ if (current[0] == '#') {
+ continue; /* commented out line */
+ }
+
+ ret = ParseConfigLine(conf, current, currentSz);
+ if (ret != WS_SUCCESS) {
+ fprintf(stderr, "Unable to parse config line : %s\n", current);
+ break;
+ }
+ }
+ XFCLOSE(f);
+
+ SetAuthKeysPattern(conf->authKeysFile);
+
+ return ret;
+}
+
+char* wolfSSHD_ConfigGetAuthKeysFile(const WOLFSSHD_CONFIG* conf)
+{
+ char* ret = NULL;
+
+ if (conf != NULL) {
+ ret = conf->authKeysFile;
+ }
+
+ return ret;
+}
+
+int wolfSSHD_ConfigSetAuthKeysFile(WOLFSSHD_CONFIG* conf, const char* file)
+{
+ int ret = WS_SUCCESS;
+
+ if (conf == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WS_SUCCESS) {
+ if (conf->authKeysFile != NULL) {
+ FreeString(&conf->authKeysFile, conf->heap);
+ conf->authKeysFile = NULL;
+ }
+
+ if (file != NULL) {
+ ret = CreateString(&conf->authKeysFile, file,
+ (int)WSTRLEN(file), conf->heap);
+ }
+ }
+
+ return ret;
+}
+
+char* wolfSSHD_ConfigGetBanner(const WOLFSSHD_CONFIG* conf)
+{
+ char* ret = NULL;
+
+ if (conf != NULL) {
+ ret = conf->banner;
+ }
+
+ return ret;
+}
+
+char* wolfSSHD_ConfigGetHostKeyFile(const WOLFSSHD_CONFIG* conf)
+{
+ char* ret = NULL;
+
+ if (conf != NULL) {
+ ret = conf->hostKeyFile;
+ }
+
+ return ret;
+}
+
+int wolfSSHD_ConfigSetHostKeyFile(WOLFSSHD_CONFIG* conf, const char* file)
+{
+ int ret = WS_SUCCESS;
+
+ if (conf == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WS_SUCCESS) {
+ if (conf->hostKeyFile != NULL) {
+ FreeString(&conf->hostKeyFile, conf->heap);
+ conf->hostKeyFile = NULL;
+ }
+
+ if (file != NULL) {
+ ret = CreateString(&conf->hostKeyFile, file,
+ (int)WSTRLEN(file), conf->heap);
+ }
+ }
+
+ return ret;
+}
+
+word16 wolfSSHD_ConfigGetPort(const WOLFSSHD_CONFIG* conf)
+{
+ word16 ret = 0;
+
+ if (conf != NULL) {
+ ret = conf->port;
+ }
+
+ return ret;
+}
+
+byte wolfSSHD_ConfigGetPermitEmptyPw(const WOLFSSHD_CONFIG* conf)
+{
+ byte ret = 0;
+
+ if (conf != NULL) {
+ ret = conf->permitEmptyPasswords;
+ }
+
+ return ret;
+}
+
+byte wolfSSHD_ConfigGetPrivilegeSeparation(const WOLFSSHD_CONFIG* conf)
+{
+ byte ret = 0;
+
+ if (conf != NULL) {
+ ret = conf->usePrivilegeSeparation;
+ }
+
+ return ret;
+}
+
+byte wolfSSHD_ConfigGetPwAuth(const WOLFSSHD_CONFIG* conf)
+{
+ byte ret = 0;
+
+ if (conf != NULL) {
+ ret = conf->passwordAuth;
+ }
+
+ return ret;
+}
+
+byte wolfSSHD_ConfigGetPermitRoot(const WOLFSSHD_CONFIG* conf)
+{
+ byte ret = 0;
+
+ if (conf != NULL) {
+ ret = conf->permitRootLogin;
+ }
+
+ return ret;
+}
+
+long wolfSSHD_ConfigGetGraceTime(const WOLFSSHD_CONFIG* conf)
+{
+ long ret = WS_BAD_ARGUMENT;
+
+ if (conf != NULL) {
+ ret = conf->loginTimer;
+ }
+
+ return ret;
+}
+#endif /* WOLFSSH_SSHD */
diff --git a/apps/wolfsshd/configuration.h b/apps/wolfsshd/configuration.h
new file mode 100644
index 00000000..3d352408
--- /dev/null
+++ b/apps/wolfsshd/configuration.h
@@ -0,0 +1,54 @@
+/* configuration.h
+ *
+ * Copyright (C) 2014-2022 wolfSSL Inc.
+ *
+ * This file is part of wolfSSH.
+ *
+ * wolfSSH is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSH is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wolfSSH. If not, see .
+ */
+
+#ifndef WOLFSSHD_H
+#define WOLFSSHD_H
+
+typedef struct WOLFSSHD_CONFIG WOLFSSHD_CONFIG;
+
+#include "auth.h"
+
+/* 0 so that privilage seperation is default on after struct memset'd on init */
+#define WOLFSSHD_PRIV_SEPARAT 0
+#define WOLFSSHD_PRIV_SANDBOX 1
+#define WOLFSSHD_PRIV_OFF 2
+
+WOLFSSHD_CONFIG* wolfSSHD_ConfigNew(void* heap);
+void wolfSSHD_ConfigFree(WOLFSSHD_CONFIG* conf);
+int wolfSSHD_ConfigLoad(WOLFSSHD_CONFIG* conf, const char* filename);
+
+char* wolfSSHD_ConfigGetBanner(const WOLFSSHD_CONFIG* conf);
+char* wolfSSHD_ConfigGetHostKeyFile(const WOLFSSHD_CONFIG* conf);
+int wolfSSHD_ConfigSetHostKeyFile(WOLFSSHD_CONFIG* conf, const char* file);
+word16 wolfSSHD_ConfigGetPort(const WOLFSSHD_CONFIG* conf);
+char* wolfSSHD_ConfigGetAuthKeysFile(const WOLFSSHD_CONFIG* conf);
+int wolfSSHD_ConfigSetAuthKeysFile(WOLFSSHD_CONFIG* conf, const char* file);
+byte wolfSSHD_ConfigGetPermitEmptyPw(const WOLFSSHD_CONFIG* conf);
+byte wolfSSHD_ConfigGetPermitRoot(const WOLFSSHD_CONFIG* conf);
+byte wolfSSHD_ConfigGetPrivilegeSeparation(const WOLFSSHD_CONFIG* conf);
+long wolfSSHD_ConfigGetGraceTime(const WOLFSSHD_CONFIG* conf);
+byte wolfSSHD_ConfigGetPwAuth(const WOLFSSHD_CONFIG* conf);
+
+#ifdef WOLFSSHD_UNIT_TEST
+int ParseConfigLine(WOLFSSHD_CONFIG* conf, const char* l, int lSz);
+#endif
+
+#endif /* WOLFSSHD_H */
+
diff --git a/apps/wolfsshd/include.am b/apps/wolfsshd/include.am
new file mode 100644
index 00000000..cc20dee1
--- /dev/null
+++ b/apps/wolfsshd/include.am
@@ -0,0 +1,23 @@
+if BUILD_SSHD
+
+bin_PROGRAMS += apps/wolfsshd/wolfsshd
+noinst_HEADERS += apps/wolfsshd/configuration.h \
+ apps/wolfsshd/auth.h
+apps_wolfsshd_wolfsshd_SOURCES = apps/wolfsshd/wolfsshd.c \
+ apps/wolfsshd/configuration.c \
+ apps/wolfsshd/auth.c
+apps_wolfsshd_wolfsshd_LDADD = src/libwolfssh.la
+apps_wolfsshd_wolfsshd_DEPENDENCIES = src/libwolfssh.la
+
+noinst_PROGRAMS += apps/wolfsshd/test/test_configuration
+apps_wolfsshd_test_test_configuration_SOURCES = apps/wolfsshd/test/test_configuration.c \
+ apps/wolfsshd/configuration.c \
+ apps/wolfsshd/auth.c
+apps_wolfsshd_test_test_configuration_LDADD = src/libwolfssh.la
+apps_wolfsshd_test_test_configuration_DEPENDENCIES = src/libwolfssh.la
+apps_wolfsshd_test_test_configuration_CPPFLAGS = -DWOLFSSH_SSHD -DWOLFSSHD_UNIT_TEST -Iapps/wolfsshd/
+
+DISTCLEANFILES+= apps/wolfsshd/.libs/wolfsshd \
+ apps/wolfsshd/test/.libs/test_configuration
+
+endif BUILD_SSHD
diff --git a/apps/wolfsshd/test/test_configuration.c b/apps/wolfsshd/test/test_configuration.c
new file mode 100644
index 00000000..4b1fe5b7
--- /dev/null
+++ b/apps/wolfsshd/test/test_configuration.c
@@ -0,0 +1,164 @@
+#include
+
+#include
+#include
+
+#ifndef WOLFSSH_DEFAULT_LOG_WIDTH
+ #define WOLFSSH_DEFAULT_LOG_WIDTH 120
+#endif
+
+#undef FMTCHECK
+#ifdef __GNUC__
+ #define FMTCHECK __attribute__((format(printf,1,2)))
+#else
+ #define FMTCHECK
+#endif /* __GNUC__ */
+
+
+void Log(const char *const, ...) FMTCHECK;
+void Log(const char *const fmt, ...)
+{
+ va_list vlist;
+ char msgStr[WOLFSSH_DEFAULT_LOG_WIDTH];
+
+ va_start(vlist, fmt);
+ WVSNPRINTF(msgStr, sizeof(msgStr), fmt, vlist);
+ va_end(vlist);
+}
+
+typedef int (*TEST_FUNC)(void);
+typedef struct {
+ const char *name;
+ TEST_FUNC func;
+} TEST_CASE;
+
+#define TEST_DECL(func) { #func, func }
+
+#define TEST_CASE_CNT (int)(sizeof(testCases) / sizeof(*testCases))
+
+static void TestSetup(const TEST_CASE* tc)
+{
+ Log("Running %s.\n", tc->name);
+}
+
+static void TestCleanup(void)
+{
+}
+
+static int RunTest(const TEST_CASE* tc)
+{
+ int ret;
+
+ TestSetup(tc);
+
+ ret = tc->func();
+ if (ret != 0) {
+ Log("%s FAILED.\n", tc->name);
+ }
+ else {
+ Log("%s PASSED.\n", tc->name);
+ }
+
+ TestCleanup();
+
+ return ret;
+}
+
+typedef struct {
+ const char* desc;
+ const char* line;
+ int shouldFail;
+} CONFIG_LINE_VECTOR;
+
+static int test_ParseConfigLine(void)
+{
+ int ret = WS_SUCCESS;
+ int i;
+ WOLFSSHD_CONFIG* conf;
+
+ static CONFIG_LINE_VECTOR vectors[] = {
+ /* Port tests. */
+ {"Valid port", "Port 22", 0},
+ {"Port too big", "Port 65536", 1},
+ {"Negative port", "Port -99", 1},
+ {"Port 0", "Port 0", 1},
+ {"Port NaN", "Port wolfsshd", 1},
+ {"Port no value", "Port \n", 1},
+
+ /* Whitespace tests. */
+ {"Extra leading whitespace", "Port 22", 0},
+ {"Extra trailing whitespace", "Port 22 \n", 0},
+
+ /* Privilege separation tests. */
+ {"Privilege separation yes", "UsePrivilegeSeparation yes", 0},
+ {"Privilege separation no", "UsePrivilegeSeparation no", 0},
+ {"Privilege separation sandbox", "UsePrivilegeSeparation sandbox", 0},
+ {"Privilege separation invalid", "UsePrivilegeSeparation wolfsshd", 1},
+
+ /* Login grace time tests. */
+ {"Valid login grace time seconds", "LoginGraceTime 60", 0},
+ {"Valid login grace time minutes", "LoginGraceTime 1m", 0},
+ {"Valid login grace time hours", "LoginGraceTime 1h", 0},
+ {"Invalid login grace time", "LoginGraceTime wolfsshd", 1},
+
+ /* Permit empty password tests. */
+ {"Permit empty password no", "PermitEmptyPasswords no", 0},
+ {"Permit empty password yes", "PermitEmptyPasswords yes", 0},
+ {"Permit empty password invalid", "PermitEmptyPasswords wolfsshd", 1},
+
+ /* Password auth tests. */
+ {"Password auth no", "PasswordAuthentication no", 0},
+ {"Password auth yes", "PasswordAuthentication yes", 0},
+ {"Password auth invalid", "PasswordAuthentication wolfsshd", 1},
+ };
+ const int numVectors = (int)(sizeof(vectors) / sizeof(*vectors));
+
+ conf = wolfSSHD_ConfigNew(NULL);
+ if (conf == NULL) {
+ ret = WS_MEMORY_E;
+ }
+
+ if (ret == WS_SUCCESS) {
+ for (i = 0; i < numVectors; ++i) {
+ Log(" Testing scenario: %s.", vectors[i].desc);
+
+ ret = ParseConfigLine(conf, vectors[i].line,
+ (int)WSTRLEN(vectors[i].line));
+
+ if ((ret == WS_SUCCESS && !vectors[i].shouldFail) ||
+ (ret != WS_SUCCESS && vectors[i].shouldFail)) {
+ Log(" PASSED.\n");
+ ret = WS_SUCCESS;
+ }
+ else {
+ Log(" FAILED.\n");
+ ret = WS_FATAL_ERROR;
+ break;
+ }
+ }
+ }
+
+ return ret;
+}
+
+const TEST_CASE testCases[] = {
+ TEST_DECL(test_ParseConfigLine)
+};
+
+int main(int argc, char** argv)
+{
+ int i;
+ int ret = WS_SUCCESS;
+
+ (void)argc;
+ (void)argv;
+
+ for (i = 0; i < TEST_CASE_CNT; ++i) {
+ ret = RunTest(&testCases[i]);
+ if (ret != WS_SUCCESS) {
+ break;
+ }
+ }
+
+ return ret;
+}
diff --git a/apps/wolfsshd/wolfsshd.c b/apps/wolfsshd/wolfsshd.c
new file mode 100644
index 00000000..a2d265df
--- /dev/null
+++ b/apps/wolfsshd/wolfsshd.c
@@ -0,0 +1,964 @@
+/* wolfsshd.c
+ *
+ * Copyright (C) 2014-2022 wolfSSL Inc.
+ *
+ * This file is part of wolfSSH.
+ *
+ * wolfSSH is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSH is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wolfSSH. If not, see .
+ */
+
+#ifdef HAVE_CONFIG_H
+ #include
+#endif
+
+#ifdef WOLFSSH_SSHD
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#define WOLFSSH_TEST_SERVER
+#include
+
+#include "configuration.h"
+#include "auth.h"
+
+#include
+
+#ifdef NO_INLINE
+ #include
+#else
+ #define WOLFSSH_MISC_INCLUDED
+ #include "src/misc.c"
+#endif
+
+#ifndef WOLFSSHD_TIMEOUT
+ #define WOLFSSHD_TIMEOUT 1
+#endif
+
+#ifdef WOLFSSH_SHELL
+ #ifdef HAVE_PTY_H
+ #include
+ #endif
+ #ifdef HAVE_UTIL_H
+ #include
+ #endif
+ #ifdef HAVE_TERMIOS_H
+ #include
+ #endif
+ #include
+ #include
+ #include
+#if defined(__QNX__) || defined(__QNXNTO__)
+ #include
+ #include
+#else
+ #include
+#endif
+
+ static volatile int ChildRunning = 0;
+ static void ChildSig(int sig)
+ {
+ (void)sig;
+ ChildRunning = 0;
+ }
+
+ static void ConnClose(int sig)
+ {
+ pid_t p;
+ int ret;
+ p = wait(&ret);
+ if (p == 0 || p == -1)
+ return; /* parent or error state*/
+ (void)ret;
+ (void)sig;
+ }
+#endif /* WOLFSSH_SHELL */
+
+static volatile byte debugMode = 0; /* default to off */
+static FILE* logFile = NULL;
+
+/* catch interrupts and close down gracefully */
+static volatile byte quit = 0;
+static const char defaultBanner[] = "wolfSSHD\n";
+
+/* Initial connection information to pass on to threads/forks */
+typedef struct WOLFSSHD_CONNECTION {
+ WOLFSSH_CTX* ctx;
+ WOLFSSHD_AUTH* auth;
+ int fd;
+ char ip[INET_ADDRSTRLEN];
+} WOLFSSHD_CONNECTION;
+
+#ifdef __unix__
+
+#include
+
+static void SyslogCb(enum wolfSSH_LogLevel level, const char *const msgStr)
+{
+ int priority;
+
+ switch (level) {
+ case WS_LOG_WARN:
+ priority = LOG_WARNING;
+ break;
+ case WS_LOG_ERROR:
+ priority = LOG_ERR;
+ break;
+ case WS_LOG_DEBUG:
+ priority = LOG_DEBUG;
+ break;
+ case WS_LOG_INFO:
+ case WS_LOG_USER:
+ case WS_LOG_SFTP:
+ case WS_LOG_SCP:
+ case WS_LOG_AGENT:
+ default:
+ priority = LOG_INFO;
+ break;
+ }
+ openlog("sshd", LOG_PID, LOG_DAEMON);
+ syslog(priority, "%s", msgStr);
+ closelog();
+}
+
+#endif
+
+static void ShowUsage(void)
+{
+ printf("wolfsshd %s\n", LIBWOLFSSH_VERSION_STRING);
+ printf(" -? display this help and exit\n");
+ printf(" -f Configuration file to use, default is "
+ "/etc/ssh/sshd_config\n");
+ printf(" -p Port number to listen on\n");
+ printf(" -d Turn on debug mode\n");
+ printf(" -D Run in foreground (do not detach)\n");
+ printf(" -h host private key file to use\n");
+ printf(" -E append to log file\n");
+}
+
+
+/* catch if interupted */
+static void interruptCatch(int in)
+{
+ (void)in;
+ if (logFile)
+ fprintf(logFile, "Closing down wolfSSHD\n");
+ quit = 1;
+}
+
+
+/* redirect logging to a specific file and add the PID value */
+static void wolfSSHDLoggingCb(enum wolfSSH_LogLevel lvl, const char *const str)
+{
+ /* always log errors and optionally log other info/debug level messages */
+ if (lvl == WS_LOG_ERROR) {
+ fprintf(logFile, "[PID %d]: %s\n", getpid(), str);
+ }
+ else if (debugMode) {
+ fprintf(logFile, "[PID %d]: %s\n", getpid(), str);
+ }
+}
+
+
+/* Frees up the WOLFSSH_CTX struct */
+static void CleanupCTX(WOLFSSHD_CONFIG* conf, WOLFSSH_CTX** ctx)
+{
+ if (ctx != NULL && *ctx != NULL) {
+ wolfSSH_CTX_free(*ctx);
+ *ctx = NULL;
+ }
+ (void)conf;
+}
+
+
+/* Initializes and sets up the WOLFSSH_CTX struct based on the configure options
+ * return WS_SUCCESS on success
+ */
+static int SetupCTX(WOLFSSHD_CONFIG* conf, WOLFSSH_CTX** ctx)
+{
+ int ret = WS_SUCCESS;
+ const char* banner;
+ DerBuffer* der = NULL;
+ byte* privBuf;
+ word32 privBufSz;
+
+ /* create a new WOLFSSH_CTX */
+ *ctx = wolfSSH_CTX_new(WOLFSSH_ENDPOINT_SERVER, NULL);
+ if (ctx == NULL) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Couldn't allocate SSH CTX data.");
+ ret = WS_MEMORY_E;
+ }
+
+ /* setup authority callback for checking peer connections */
+ if (ret == WS_SUCCESS) {
+ wolfSSH_SetUserAuth(*ctx, DefaultUserAuth);
+ }
+
+ /* set banner to display on connection */
+ if (ret == WS_SUCCESS) {
+ banner = wolfSSHD_ConfigGetBanner(conf);
+ if (banner == NULL) {
+ banner = defaultBanner;
+ }
+ wolfSSH_CTX_SetBanner(*ctx, banner);
+ }
+
+ /* Load in host private key */
+ if (ret == WS_SUCCESS) {
+
+ char* hostKey = wolfSSHD_ConfigGetHostKeyFile(conf);
+
+ if (hostKey == NULL) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] No host private key set");
+ ret = WS_BAD_ARGUMENT;
+ }
+ else {
+ FILE* f;
+
+ f = XFOPEN(hostKey, "rb");
+ if (f == NULL) {
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Unable to open host private key");
+ ret = WS_BAD_ARGUMENT;
+ }
+ else {
+ byte* data;
+ int dataSz = 4096;
+
+ data = (byte*)WMALLOC(dataSz, NULL, 0);
+
+ dataSz = (int)XFREAD(data, 1, dataSz, f);
+ XFCLOSE(f);
+
+ if (wc_PemToDer(data, dataSz, PRIVATEKEY_TYPE, &der, NULL,
+ NULL, NULL) != 0) {
+ wolfSSH_Log(WS_LOG_DEBUG, "[SSHD] Failed to convert host "
+ "private key from PEM. Assuming key in DER "
+ "format.");
+ privBuf = data;
+ privBufSz = dataSz;
+ }
+ else {
+ privBuf = der->buffer;
+ privBufSz = der->length;
+ }
+
+ if (wolfSSH_CTX_UsePrivateKey_buffer(*ctx, privBuf, privBufSz,
+ WOLFSSH_FORMAT_ASN1) < 0) {
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Failed to use host private key.");
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ WFREE(data, NULL, 0);
+ wc_FreeDer(&der);
+ }
+ }
+ }
+
+ /* @TODO Load in host public key */
+
+ /* Set allowed connection type, i.e. public key / password */
+
+ return ret;
+}
+
+
+#ifdef WOLFSSH_SFTP
+#define TEST_SFTP_TIMEOUT 1
+
+/* handle SFTP operations
+ * returns 0 on success
+ */
+static int SFTP_Subsystem(WOLFSSH* ssh, WOLFSSHD_CONNECTION* conn)
+{
+ byte tmp[1];
+ int ret = WS_SUCCESS;
+ int error = WS_SUCCESS;
+ WS_SOCKET_T sockfd;
+ int select_ret = 0;
+
+ sockfd = (WS_SOCKET_T)wolfSSH_get_fd(ssh);
+ do {
+ if (wolfSSH_stream_peek(ssh, tmp, 1) > 0) {
+ select_ret = WS_SELECT_RECV_READY;
+ }
+ else {
+ select_ret = tcp_select(sockfd, TEST_SFTP_TIMEOUT);
+ }
+
+ if (select_ret == WS_SELECT_RECV_READY ||
+ select_ret == WS_SELECT_ERROR_READY ||
+ error == WS_WANT_WRITE)
+ {
+ ret = wolfSSH_SFTP_read(ssh);
+ error = wolfSSH_get_error(ssh);
+ }
+ else if (select_ret == WS_SELECT_TIMEOUT)
+ error = WS_WANT_READ;
+ else
+ error = WS_FATAL_ERROR;
+
+ if (error == WS_WANT_READ || error == WS_WANT_WRITE ||
+ error == WS_CHAN_RXD || error == WS_REKEYING ||
+ error == WS_WINDOW_FULL)
+ ret = error;
+
+ if (ret == WS_FATAL_ERROR && error == 0) {
+ WOLFSSH_CHANNEL* channel =
+ wolfSSH_ChannelNext(ssh, NULL);
+ if (channel && wolfSSH_ChannelGetEof(channel)) {
+ ret = 0;
+ break;
+ }
+ }
+ } while (ret != WS_FATAL_ERROR);
+
+ (void)conn;
+ return ret;
+}
+#endif
+
+
+#ifdef WOLFSSH_SHELL
+
+#ifndef MAX_COMMAND_SZ
+ #define MAX_COMMAND_SZ 80
+#endif
+
+static int SHELL_Subsystem(WOLFSSHD_CONNECTION* conn, WOLFSSH* ssh)
+{
+ WS_SOCKET_T sshFd = 0;
+ int rc;
+ const char *userName;
+ struct passwd *p_passwd;
+ WS_SOCKET_T childFd = 0;
+ pid_t childPid;
+#ifndef EXAMPLE_BUFFER_SZ
+ #define EXAMPLE_BUFFER_SZ 4096
+#endif
+ byte shellBuffer[EXAMPLE_BUFFER_SZ];
+ byte channelBuffer[EXAMPLE_BUFFER_SZ];
+
+ userName = wolfSSH_GetUsername(ssh);
+ if (userName == NULL) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Failure get user name");
+ return WS_FATAL_ERROR;
+ }
+
+ /* temporarily elevate permissions to get users information */
+ if (wolfSSHD_AuthRaisePermissions(conn->auth) != WS_SUCCESS) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Failure to raise permissions for auth");
+ return WS_FATAL_ERROR;
+ }
+
+ p_passwd = getpwnam((const char *)userName);
+ if (p_passwd == NULL) {
+ /* Not actually a user on the system. */
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Invalid user name found");
+ if (wolfSSHD_AuthReducePermissions(conn->auth) != WS_SUCCESS) {
+ /* stop everything if not able to reduce permissions level */
+ exit(1);
+ }
+
+ return WS_FATAL_ERROR;
+ }
+
+ ChildRunning = 1;
+ childPid = forkpty(&childFd, NULL, NULL, NULL);
+ if (childPid < 0) {
+ /* forkpty failed, so return */
+ ChildRunning = 0;
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Issue creating new forkpty");
+ return WS_FATAL_ERROR;
+ }
+ else if (childPid == 0) {
+ /* Child process */
+ char cmd[MAX_COMMAND_SZ];
+ int ret;
+
+ signal(SIGINT, SIG_DFL);
+ signal(SIGCHLD, SIG_DFL);
+
+ setenv("HOME", p_passwd->pw_dir, 1);
+ setenv("LOGNAME", p_passwd->pw_name, 1);
+ rc = chdir(p_passwd->pw_dir);
+ if (rc != 0) {
+ return WS_FATAL_ERROR;
+ }
+
+ /* default to /bin/sh if user shell is not set */
+ WMEMSET(cmd, 0, sizeof(cmd));
+ if (XSTRLEN(p_passwd->pw_shell) == 0) {
+ #if defined(__QNX__) || defined(__QNXNTO__)
+ XSNPRINTF(cmd, sizeof(cmd), "su - %s -c %s", userName,
+ "/bin/sh");
+ #else
+ XSNPRINTF(cmd, sizeof(cmd), "runuser -u %s -- %s", userName,
+ "/bin/sh");
+ #endif
+ }
+ else {
+ #if defined(__QNX__) || defined(__QNXNTO__)
+ XSNPRINTF(cmd, sizeof(cmd), "su - %s -c %s", userName,
+ p_passwd->pw_shell);
+ #else
+ XSNPRINTF(cmd, sizeof(cmd), "runuser -u %s -- %s", userName,
+ p_passwd->pw_shell);
+ #endif
+ }
+
+ errno = 0;
+ ret = system(cmd);
+ if (ret && errno) {
+ perror("error executing shell command ");
+ exit(1);
+ }
+ exit(0); /* exit child process and close down SSH connection */
+ }
+
+ if (wolfSSHD_AuthReducePermissions(conn->auth) != WS_SUCCESS) {
+ /* stop everything if not able to reduce permissions level */
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Issue reducing permissions level,"
+ " exiting now");
+ exit(1);
+ }
+
+ sshFd = wolfSSH_get_fd(ssh);
+
+ struct termios tios;
+ word32 shellChannelId = 0;
+ signal(SIGCHLD, ChildSig);
+ signal(SIGINT, SIG_DFL);
+
+ rc = tcgetattr(childFd, &tios);
+ if (rc != 0) {
+ return WS_FATAL_ERROR;
+ }
+ rc = tcsetattr(childFd, TCSAFLUSH, &tios);
+ if (rc != 0) {
+ return WS_FATAL_ERROR;
+ }
+
+ while (ChildRunning) {
+ byte tmp[2];
+ fd_set readFds;
+ WS_SOCKET_T maxFd;
+ int cnt_r;
+ int cnt_w;
+ int pending = 0;
+
+ FD_ZERO(&readFds);
+ FD_SET(sshFd, &readFds);
+ maxFd = sshFd;
+
+ FD_SET(childFd, &readFds);
+ if (childFd > maxFd)
+ maxFd = childFd;
+
+ if (wolfSSH_stream_peek(ssh, tmp, 1) <= 0) {
+ rc = select((int)maxFd + 1, &readFds, NULL, NULL, NULL);
+ if (rc == -1)
+ break;
+ }
+ else {
+ pending = 1; /* found some pending SSH data */
+ }
+
+ if (pending || FD_ISSET(sshFd, &readFds)) {
+ word32 lastChannel = 0;
+
+ /* The following tries to read from the first channel inside
+ the stream. If the pending data in the socket is for
+ another channel, this will return an error with id
+ WS_CHAN_RXD. That means the agent has pending data in its
+ channel. The additional channel is only used with the
+ agent. */
+ cnt_r = wolfSSH_worker(ssh, &lastChannel);
+ if (cnt_r < 0) {
+ rc = wolfSSH_get_error(ssh);
+ if (rc == WS_CHAN_RXD) {
+ if (lastChannel == shellChannelId) {
+ cnt_r = wolfSSH_ChannelIdRead(ssh, shellChannelId,
+ channelBuffer,
+ sizeof channelBuffer);
+ if (cnt_r <= 0)
+ break;
+ cnt_w = (int)write(childFd,
+ channelBuffer, cnt_r);
+ if (cnt_w <= 0)
+ break;
+ }
+ }
+ else if (rc == WS_CHANNEL_CLOSED) {
+ continue;
+ }
+ else if (rc != WS_WANT_READ) {
+ break;
+ }
+ }
+ }
+
+ if (FD_ISSET(childFd, &readFds)) {
+ cnt_r = (int)read(childFd, shellBuffer, sizeof shellBuffer);
+ /* This read will return 0 on EOF */
+ if (cnt_r <= 0) {
+ int err = errno;
+ if (err != EAGAIN) {
+ break;
+ }
+ }
+ else {
+ if (cnt_r > 0) {
+ cnt_w = wolfSSH_ChannelIdSend(ssh, shellChannelId,
+ shellBuffer, cnt_r);
+ if (cnt_w < 0)
+ break;
+ }
+ }
+ }
+ }
+
+ (void)conn;
+ return WS_SUCCESS;
+}
+#endif
+
+static __thread int timeOut = 0;
+static void alarmCatch(int signum)
+{
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Failed login within grace period");
+ timeOut = 1;
+ (void)signum;
+}
+
+/* handle wolfSSH accept and directing to correct subsystem */
+static void* HandleConnection(void* arg)
+{
+ int ret = WS_SUCCESS;
+
+ WOLFSSHD_CONNECTION* conn = NULL;
+ WOLFSSH* ssh = NULL;
+
+ if (arg == NULL) {
+ ret = WS_BAD_ARGUMENT;
+ }
+
+ if (ret == WS_SUCCESS) {
+ conn = (WOLFSSHD_CONNECTION*)arg;
+ ssh = wolfSSH_new(conn->ctx);
+ if (ssh == NULL) {
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Failed to create new WOLFSSH struct");
+ ret = -1;
+ }
+ }
+
+ if (ret == WS_SUCCESS) {
+ int error;
+ int select_ret = 0;
+ long graceTime;
+
+ wolfSSH_set_fd(ssh, conn->fd);
+ wolfSSH_SetUserAuthCtx(ssh, conn->auth);
+
+ /* set alarm for login grace time */
+ graceTime = wolfSSHD_AuthGetGraceTime(conn->auth);
+ if (graceTime > 0) {
+ signal(SIGALRM, alarmCatch);
+ alarm((unsigned int)graceTime);
+ }
+
+ ret = wolfSSH_accept(ssh);
+ error = wolfSSH_get_error(ssh);
+ while (timeOut == 0 && (ret != WS_SUCCESS
+ && ret != WS_SCP_COMPLETE && ret != WS_SFTP_COMPLETE)
+ && (error == WS_WANT_READ || error == WS_WANT_WRITE)) {
+
+ select_ret = tcp_select(conn->fd, 1);
+ if (select_ret == WS_SELECT_RECV_READY ||
+ select_ret == WS_SELECT_ERROR_READY ||
+ error == WS_WANT_WRITE)
+ {
+ ret = wolfSSH_accept(ssh);
+ error = wolfSSH_get_error(ssh);
+ }
+ else if (select_ret == WS_SELECT_TIMEOUT)
+ error = WS_WANT_READ;
+ else
+ error = WS_FATAL_ERROR;
+ }
+
+ if (ret != WS_SUCCESS && ret != WS_SFTP_COMPLETE) {
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Failed to accept WOLFSSH connection from %s",
+ conn->ip);
+ }
+ }
+
+ if (ret == WS_SUCCESS || ret == WS_SFTP_COMPLETE) {
+ switch (wolfSSH_GetSessionType(ssh)) {
+ case WOLFSSH_SESSION_SHELL:
+ #ifdef WOLFSSH_SHELL
+ if (ret == WS_SUCCESS) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Entering new shell");
+ SHELL_Subsystem(conn, ssh);
+ }
+ #else
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Shell support is disabled");
+ ret = WS_NOT_COMPILED;
+ #endif
+ break;
+
+ case WOLFSSH_SESSION_SUBSYSTEM:
+ /* test for known subsystems */
+ switch (ret) {
+ case WS_SFTP_COMPLETE:
+ #ifdef WOLFSSH_SFTP
+ ret = SFTP_Subsystem(ssh, conn);
+ #else
+ err_sys("SFTP not compiled in. Please use --enable-sftp");
+ #endif
+ break;
+
+ default:
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Unknown or build not supporting subsystem"
+ " found [%s]", wolfSSH_GetSessionCommand(ssh));
+ ret = WS_NOT_COMPILED;
+ }
+ break;
+
+ case WOLFSSH_SESSION_UNKNOWN:
+ case WOLFSSH_SESSION_EXEC:
+ case WOLFSSH_SESSION_TERMINAL:
+ default:
+ wolfSSH_Log(WS_LOG_ERROR,
+ "[SSHD] Unknown or build not supporting session type found");
+ ret = WS_NOT_COMPILED;
+ }
+ }
+
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Attempting to close down connection");
+ wolfSSH_shutdown(ssh);
+ wolfSSH_free(ssh);
+ if (conn != NULL) {
+ WCLOSESOCKET(conn->fd);
+ }
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Return from closing connection = %d", ret);
+
+ return NULL;
+}
+
+
+/* returns WS_SUCCESS on success */
+static int NewConnection(WOLFSSHD_CONNECTION* conn)
+{
+ int pd;
+ int ret = WS_SUCCESS;
+
+ pd = fork();
+ if (pd < 0) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Issue spawning new process");
+ ret = -1;
+ }
+
+ if (ret == WS_SUCCESS) {
+ if (pd == 0) {
+ /* child process */
+ signal(SIGINT, SIG_DFL);
+ (void)HandleConnection((void*)conn);
+ exit(0);
+ }
+ else {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Spawned new process %d\n", pd);
+ }
+ }
+
+ return ret;
+}
+
+
+/* return non zero value for a pending connection */
+static int PendingConnection(WS_SOCKET_T fd)
+{
+ int ret;
+ struct timeval t;
+ fd_set r, w, e;
+ WS_SOCKET_T nfds = fd + 1;
+
+ t.tv_usec = 0;
+ t.tv_sec = WOLFSSHD_TIMEOUT;
+
+ FD_ZERO(&r);
+ FD_ZERO(&w);
+ FD_ZERO(&e);
+
+ FD_SET(fd, &r);
+ errno = 0;
+ ret = select(nfds, &r, &w, &e, &t);
+ if (ret < 0) {
+ /* a socket level issue happend, could just be a system call int. */
+ if (errno != EINTR) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] TCP socket error on select()");
+ quit = 1;
+ }
+ ret = 0;
+ }
+ else if (ret > 0) {
+ if (FD_ISSET(fd, &r)) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Incoming TCP data found");
+ }
+ else {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Found TCP write or error data");
+ ret = 0; /* nothing to read */
+ }
+ }
+ return ret;
+}
+
+
+int myoptind = 0;
+char* myoptarg = NULL;
+
+int main(int argc, char** argv)
+{
+ int ret = WS_SUCCESS;
+ word16 port = 0;
+ WS_SOCKET_T listenFd = 0;
+ int ch;
+ WOLFSSHD_CONFIG* conf = NULL;
+ WOLFSSHD_AUTH* auth = NULL;
+ WOLFSSH_CTX* ctx = NULL;
+ byte isDaemon = 1;
+
+ const char* configFile = "/etc/ssh/sshd_config";
+ const char* hostKeyFile = NULL;
+
+ signal(SIGINT, interruptCatch);
+
+ wolfSSH_SetLoggingCb(wolfSSHDLoggingCb);
+ wolfSSH_Debugging_ON();
+#ifdef DEBUG_WOLFSSL
+ wolfSSL_Debugging_ON();
+#endif
+
+ logFile = stderr;
+ if (ret == WS_SUCCESS) {
+ wolfSSH_Init();
+ }
+
+ if (ret == WS_SUCCESS) {
+ conf = wolfSSHD_ConfigNew(NULL);
+ if (conf == NULL) {
+ ret = WS_MEMORY_E;
+ }
+ }
+
+ while ((ch = mygetopt(argc, argv, "?f:p:h:dDE:")) != -1) {
+ switch (ch) {
+ case 'f':
+ configFile = myoptarg;
+ break;
+
+ case 'p':
+ if (ret == WS_SUCCESS) {
+ ret = XATOI(myoptarg);
+ if (ret < 0) {
+ fprintf(stderr, "Issue parsing port number %s\n",
+ myoptarg);
+ ret = WS_BAD_ARGUMENT;
+ }
+ else {
+ if (ret <= (word16)-1) {
+ port = (word16)ret;
+ ret = WS_SUCCESS;
+ }
+ else {
+ fprintf(stderr, "Port number %d too big.\n", ret);
+ ret = WS_BAD_ARGUMENT;
+ }
+ }
+ }
+ break;
+
+ case 'h':
+ hostKeyFile = myoptarg;
+ break;
+
+ case 'd':
+ debugMode = 1; /* turn on debug mode */
+ break;
+
+ case 'D':
+ isDaemon = 0;
+ break;
+
+ case 'E':
+ logFile = fopen(myoptarg, "ab");
+ if (logFile == NULL) {
+ fprintf(stderr, "Unable to open log file %s\n", myoptarg);
+ ret = WS_FATAL_ERROR;
+ }
+ break;
+
+ case '?':
+ ShowUsage();
+ return WS_SUCCESS;
+
+ default:
+ ShowUsage();
+ return WS_SUCCESS;
+ }
+ }
+
+ if (ret == WS_SUCCESS) {
+ ret = wolfSSHD_ConfigLoad(conf, configFile);
+ if (ret != WS_SUCCESS)
+ fprintf(stderr, "Error reading in configure file %s\n", configFile);
+ }
+
+ /* port was not overridden with argument, read from config file */
+ if (ret == WS_SUCCESS && port == 0) {
+ port = wolfSSHD_ConfigGetPort(conf);
+ }
+
+ /* check if host key file was passed in */
+ if (hostKeyFile != NULL) {
+ wolfSSHD_ConfigSetHostKeyFile(conf, hostKeyFile);
+ }
+
+ if (ret == WS_SUCCESS) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Starting wolfSSH SSHD application");
+ ret = SetupCTX(conf, &ctx);
+ }
+ else {
+ /* TODO: handle error. */
+ }
+
+ if (ret == WS_SUCCESS) {
+ auth = wolfSSHD_AuthCreateUser(NULL, conf);
+ if (auth == NULL) {
+ wolfSSH_Log(WS_LOG_ERROR, "[SSHD] Issue creating auth struct");
+ ret = WS_MEMORY_E;
+ }
+ }
+
+ /* seperate privlage permisions */
+ if (ret == WS_SUCCESS) {
+ if (wolfSSHD_AuthReducePermissions(auth) != WS_SUCCESS) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Error lowering permissions level");
+ ret = WS_FATAL_ERROR;
+ }
+ }
+
+ if (logFile == NULL) {
+ logFile = stderr;
+ }
+
+ /* run as a daemon */
+ if (ret == WS_SUCCESS && isDaemon) {
+#ifdef __unix__
+ /* Daemonizing in POSIX, so set a syslog based log */
+ wolfSSH_SetLoggingCb(SyslogCb);
+#endif
+ pid_t p;
+
+ p = fork();
+ if (p < 0) {
+ fprintf(stderr, "Failed to fork process\n");
+ ret = WS_FATAL_ERROR;
+ }
+
+ if (ret == WS_SUCCESS) {
+ if (p > 0) {
+ exit(0); /* stop parent process */
+ }
+
+ if (setsid() < 0) {
+ fprintf(stderr, "Failed to set a new session");
+ ret = WS_FATAL_ERROR;
+ }
+ }
+ }
+
+ signal(SIGCHLD, ConnClose);
+ if (ret == WS_SUCCESS) {
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Starting to listen on port %d", port);
+ tcp_listen(&listenFd, &port, 1);
+ wolfSSH_Log(WS_LOG_INFO, "[SSHD] Listening on port %d", port);
+
+ /* wait for incoming connections and fork them off */
+ while (ret == WS_SUCCESS && quit == 0) {
+ WOLFSSHD_CONNECTION conn;
+ #ifdef WOLFSSL_NUCLEUS
+ struct addr_struct clientAddr;
+ #else
+ SOCKADDR_IN_T clientAddr;
+ socklen_t clientAddrSz = sizeof(clientAddr);
+ #endif
+ conn.auth = auth;
+
+ /* wait for a connection */
+ if (PendingConnection(listenFd)) {
+ conn.ctx = ctx;
+ #ifdef WOLFSSL_NUCLEUS
+ conn.fd = NU_Accept(listenFd, &clientAddr, 0);
+ #else
+ conn.fd = accept(listenFd, (struct sockaddr*)&clientAddr,
+ &clientAddrSz);
+ if (conn.fd >= 0) {
+ inet_ntop(AF_INET, &clientAddr.sin_addr, conn.ip,
+ INET_ADDRSTRLEN);
+ }
+ #endif
+
+ {
+ #ifdef USE_WINDOWS_API
+ unsigned long blocking = 1;
+ int ret = ioctlsocket(conn.fd, FIONBIO, &blocking);
+ if (ret == SOCKET_ERROR)
+ err_sys("ioctlsocket failed");
+ #elif defined(WOLFSSL_MDK_ARM) || defined(WOLFSSL_KEIL_TCP_NET) \
+ || defined (WOLFSSL_TIRTOS)|| defined(WOLFSSL_VXWORKS) || \
+ defined(WOLFSSL_NUCLEUS)
+ /* non blocking not supported, for now */
+ #else
+ int flags = fcntl(conn.fd, F_GETFL, 0);
+ if (flags < 0)
+ err_sys("fcntl get failed");
+ flags = fcntl(conn.fd, F_SETFL, flags | O_NONBLOCK);
+ if (flags < 0)
+ err_sys("fcntl set failed");
+ #endif
+ }
+ ret = NewConnection(&conn);
+ }
+ }
+ }
+
+ CleanupCTX(conf, &ctx);
+ wolfSSHD_ConfigFree(conf);
+ wolfSSHD_AuthFreeUser(auth);
+ wolfSSH_Cleanup();
+
+ return 0;
+}
+#endif /* WOLFSSH_SSHD */
diff --git a/configure.ac b/configure.ac
index 88ecbe93..8f052afb 100644
--- a/configure.ac
+++ b/configure.ac
@@ -113,8 +113,8 @@ AC_ARG_WITH(wolfssl,
if test -d "${withval}/lib" && test -d "${withval}/include"; then
wcpath=${withval}
- LDFLAGS="$LDFLAGS -L${wcpath}/lib"
- CPPFLAGS="$CPPFLAGS -I${wcpath}/include"
+ LDFLAGS="-L${wcpath}/lib $LDFLAGS"
+ CPPFLAGS="-I${wcpath}/include $CPPFLAGS"
else
AC_MSG_ERROR([wolfSSL path error (${withval}): missing lib and include])
fi
@@ -171,6 +171,11 @@ AC_ARG_ENABLE([sftp],
[AS_HELP_STRING([--enable-sftp],[Enable SFTP support (default: disabled)])],
[ENABLED_SFTP=$enableval],[ENABLED_SFTP=no])
+# SSHD
+AC_ARG_ENABLE([sshd],
+ [AS_HELP_STRING([--enable-sshd],[Enable SSHD support (default: disabled)])],
+ [ENABLED_SSHD=$enableval],[ENABLED_SSHD=no])
+
# TCP/IP Forwarding
AC_ARG_ENABLE([fwd],
[AS_HELP_STRING([--enable-fwd],[Enable TCP/IP Forwarding support (default: disabled)])],
@@ -196,6 +201,12 @@ AC_ARG_ENABLE([smallstack],
[AS_HELP_STRING([--enable-smallstack],[Enable small stack (default: disabled)])],
[ENABLED_SMALLSTACK=$enableval],[ENABLED_SMALLSTACK=no])
+# use PAM lib
+AC_ARG_WITH([pam],
+ [AS_HELP_STRING([--with-pam=PATH],[PATH to directory with the PAM library])],
+ [PAM_LIB=$withval],
+ [PAM_LIB=""])
+
# Enable All
AC_ARG_ENABLE([all],
[AS_HELP_STRING([--enable-all],[Enable all wolfSSH features (default: disabled)])],
@@ -210,7 +221,9 @@ AC_ARG_ENABLE([distro],
AS_IF([test "x$ENABLED_DISTRO" = "xyes"],
[ENABLED_ALL=yes; enable_shared=yes; enable_static=yes])
AS_IF([test "x$ENABLED_ALL" = "xyes"],
- [ENABLED_KEYGEN=yes; ENABLED_SCP=yes; ENABLED_SFTP=yes; ENABLED_FWD=yes; ENABLED_SHELL=yes; ENABLED_AGENT=yes])
+ [ENABLED_KEYGEN=yes; ENABLED_SCP=yes; ENABLED_SFTP=yes; ENABLED_FWD=yes; ENABLED_SHELL=yes; ENABLED_AGENT=yes; ENABLED_SSHD=yes])
+AS_IF([test "x$ENABLED_SSHD" = "xyes"],
+ [ENABLED_SHELL=yes])
# Set the defined flags for the code.
AS_IF([test "x$ENABLED_INLINE" = "xno"],
@@ -230,6 +243,47 @@ AS_IF([test "x$ENABLED_SHELL" = "xyes"],
AS_IF([test "x$ENABLED_AGENT" = "xyes"],[AM_CPPFLAGS="$AM_CPPFLAGS -DWOLFSSH_AGENT"])
AS_IF([test "x$ENABLED_SMALLSTACK" = "xyes"],
[AM_CPPFLAGS="$AM_CPPFLAGS -DWOLFSSH_SMALL_STACK"])
+AS_IF([test "x$ENABLED_SSHD" = "xyes"],
+ [AM_CPPFLAGS="$AM_CPPFLAGS -DWOLFSSH_SSHD"])
+
+if test "$ENABLED_SSHD" = "yes"; then
+ if test -n "$PAM_LIB"
+ then
+ AC_MSG_CHECKING([for directory $PAM_LIB])
+ if ! test -d "$PAM_LIB"
+ then
+ AC_MSG_ERROR([PAM lib dir $PAM_LIB not found.])
+ fi
+ AC_MSG_RESULT([yes])
+ AM_LDFLAGS="-L$PAM_LIB $AM_LDFLAGS"
+
+ LIBS="$LIBS -lpam"
+ AM_CPPFLAGS="$AM_CPPFLAGS -DWOLFSSH_USE_PAM"
+ #TODO check on link to lib
+ #AC_CHECK_LIB([pam], [pam],
+ # [AM_CPPFLAGS="$AM_CPPFLAGS -DWOLFSSH_USE_PAM"; LIBS="$LIBS -lpam"],
+ # [AC_MSG_ERROR(libpam not found)])
+ else
+ case $host in
+ *qnx*)
+ # QNX uses liblogin for crypt operation
+ AC_CHECK_LIB([login], [login],
+ [AM_CPPFLAGS="$AM_CPPFLAGS -DWOLFSSH_HAVE_LIBLOGIN";
+ LIBS="$LIBS -llogin"],
+ [AC_MSG_ERROR(liblogin not found)])
+ ;;
+ *darwin*)
+ AM_CPPFLAGS="$AM_CPPFLAGS -DWOLFSSH_HAVE_LIBCRYPT"
+ ;;
+ *)
+ AC_CHECK_LIB([crypt], [crypt],
+ [AM_CPPFLAGS="$AM_CPPFLAGS -DWOLFSSH_HAVE_LIBCRYPT";
+ LIBS="$LIBS -lcrypt"],
+ [AC_MSG_ERROR(libcrypt not found)])
+ esac
+ fi
+fi
+
# Set the automake conditionals.
AM_CONDITIONAL([BUILD_EXAMPLE_SERVERS],[test "x$ENABLED_EXAMPLES" = "xyes"])
@@ -242,6 +296,7 @@ AM_CONDITIONAL([BUILD_FWD],[test "x$ENABLED_FWD" = "xyes"])
AM_CONDITIONAL([BUILD_TERM],[test "x$ENABLED_TERM" = "xyes"])
AM_CONDITIONAL([BUILD_SHELL],[test "x$ENABLED_SHELL" = "xyes"])
AM_CONDITIONAL([BUILD_AGENT],[test "x$ENABLED_AGENT" = "xyes"])
+AM_CONDITIONAL([BUILD_SSHD],[test "x$ENABLED_SSHD" = "xyes"])
AX_HARDEN_CC_COMPILER_FLAGS
@@ -282,6 +337,7 @@ AS_ECHO([" * psuedo-terminal: $ENABLED_PTERM"])
AS_ECHO([" * echoserver shell support: $ENABLED_SHELL"])
AS_ECHO([" * scp: $ENABLED_SCP"])
AS_ECHO([" * sftp: $ENABLED_SFTP"])
+AS_ECHO([" * sshd: $ENABLED_SSHD"])
AS_ECHO([" * agent: $ENABLED_AGENT"])
AS_ECHO([" * TCP/IP Forwarding: $ENABLED_FWD"])
AS_ECHO([" * Examples: $ENABLED_EXAMPLES"])
diff --git a/examples/echoserver/echoserver.c b/examples/echoserver/echoserver.c
index 7b181011..e62389f9 100644
--- a/examples/echoserver/echoserver.c
+++ b/examples/echoserver/echoserver.c
@@ -69,6 +69,12 @@
#endif
#include
#include
+#if defined(__QNX__) || defined(__QNXNTO__)
+ #include
+ #include
+#else
+ #include
+#endif
#endif /* WOLFSSH_SHELL */
#ifdef WOLFSSH_AGENT
diff --git a/src/log.c b/src/log.c
index 45621f1d..e67ac970 100644
--- a/src/log.c
+++ b/src/log.c
@@ -57,7 +57,7 @@
#endif /* WOLFSSH_NO_DEFAULT_LOGGING_CB */
-#ifdef DEBUG_WOLFSSH
+#if defined(DEBUG_WOLFSSH) || defined(WOLFSSH_SSHD)
static enum wolfSSH_LogLevel logLevel = WS_LOG_DEFAULT;
static int logEnable = 0;
#endif
@@ -66,7 +66,7 @@
/* turn debugging on if supported */
void wolfSSH_Debugging_ON(void)
{
-#ifdef DEBUG_WOLFSSH
+#if defined(DEBUG_WOLFSSH) || defined(WOLFSSH_SSHD)
logEnable = 1;
#endif
}
@@ -75,7 +75,7 @@ void wolfSSH_Debugging_ON(void)
/* turn debugging off */
void wolfSSH_Debugging_OFF(void)
{
-#ifdef DEBUG_WOLFSSH
+#if defined(DEBUG_WOLFSSH) || defined(WOLFSSH_SSHD)
logEnable = 0;
#endif
}
@@ -91,7 +91,7 @@ void wolfSSH_SetLoggingCb(wolfSSH_LoggingCb logF)
int wolfSSH_LogEnabled(void)
{
-#ifdef DEBUG_WOLFSSH
+#if defined(DEBUG_WOLFSSH) || defined(WOLFSSH_SSHD)
return logEnable;
#else
return 0;
@@ -99,7 +99,7 @@ int wolfSSH_LogEnabled(void)
}
-#ifdef DEBUG_WOLFSSH
+#if defined(DEBUG_WOLFSSH) || defined(WOLFSSH_SSHD)
#ifndef WOLFSSH_NO_DEFAULT_LOGGING_CB
/* log level string */
static const char* GetLogStr(enum wolfSSH_LogLevel level)
diff --git a/wolfssh/internal.h b/wolfssh/internal.h
index 325d12e9..01229c47 100644
--- a/wolfssh/internal.h
+++ b/wolfssh/internal.h
@@ -978,7 +978,8 @@ enum WS_DynamicTypes {
DYNTYPE_AGENT_BUFFER,
DYNTYPE_FILE,
DYNTYPE_TEMP,
- DYNTYPE_PATH
+ DYNTYPE_PATH,
+ DYNTYPE_SSHD
};
diff --git a/wolfssh/port.h b/wolfssh/port.h
index 7efb1e25..c89cffdd 100644
--- a/wolfssh/port.h
+++ b/wolfssh/port.h
@@ -41,6 +41,15 @@ extern "C" {
/* This value needs to stay in sync with the actual value of DYNTYPE_STRING
* from internal.h. */
+#ifdef WOLFSSH_SSHD
+ /* uses isspace (not always available from wolfSSL) */
+ #ifdef XISSPACE
+ #define WISSPACE XISSPACE
+ #else
+ #define WISSPACE isspace
+ #endif
+#endif
+
/* setup memory handling */
#ifndef WMALLOC_USER
#ifdef WOLFSSL_USER_SETTINGS