OpenSSH 3.0

The Doctor doctor at doctor.nl2k.ab.ca
Wed Nov 7 11:25:29 EST 2001


On Tue, Nov 06, 2001 at 04:48:41PM -0500, Markus Friedl wrote:
> OpenSSH 3.0 has just been released. It will be available from the
> mirrors listed at http://www.openssh.com/ shortly.
> 
> OpenSSH is a 100% complete SSH protocol version 1.3, 1.5 and 2.0
> implementation and includes sftp client and server support.
> 
> This release contains many portability bug-fixes (listed in the
> ChangeLog) as well as several new features (listed below).
> 
> We would like to thank the OpenSSH community for their continued
> support and encouragement.
> 
> Important Changes:
> ==================
> 
> 1) SSH protocol v2 is now the default protocol version
> 
> 	use the 'Protocol' option from ssh(1) and sshd(8) if
> 	you need to change this.
> 
> 2) The files
> 	/etc/ssh_known_hosts2
> 	~/.ssh/known_hosts2
> 	~/.ssh/authorized_keys2
>    are now obsolete, you can use
> 	/etc/ssh_known_hosts
> 	~/.ssh/known_hosts
> 	~/.ssh/authorized_keys
>    For backward compatibility ~/.ssh/authorized_keys2 will still used for
>    authentication and hostkeys are still read from the known_hosts2.
>    However, those deprecated files are considered 'readonly'.  Future
>    releases are likely not to read these files.
> 
> 3) The CheckMail option in sshd_config is deprecated, as sshd(8) no longer
>    checks for new mail.
> 
> 4) X11 cookies are now stored in $HOME.
> 
> New Features:
> =============
> 
> 1) Smartcard support in the ssh client and agent based on work by
>    University of Michigan CITI (http://www.citi.umich.edu/projects/smartcard/).
> 
> 2) support for Rekeying in protocol version 2
> 
> 3) improved Kerberos support in protocol v1 (KerbIV and KerbV)
> 
> 4) backward compatibility with older commercial SSH versions >= 2.0.10
> 
> 5) getopt(3) is now used by all programs
> 
> 6) dynamic forwarding (use ssh(1) as your socks server)
> 
> 7) ClearAllForwardings in ssh(1)
> 
> 8) ssh(1) now checks the hostkey for localhost (NoHostAuthenticationForLocalhost yes/no).
> 
> 9) -F option in ssh(1)
> 
> 10) ssh(1) now has a '-b bindaddress' option
> 
> 11) scp(1) allows "scp /file localhost:/file"
> 
> 12) The AuthorizedKeysFile option allows specification of alternative
>     files that contain the public keys that can be used for user authentication
>     (e.g. /etc/ssh_keys/%u, see sshd(8))
> 
> 13) extended AllowUsers user at host syntax in sshd(8)
> 
> 14) improved challenge-response support (especially for systems supporting BSD_AUTH)
> 
> 15) sshd(8) can specify time args as 1h, 2h30s etc.
> 
> 16) sshd(8) transmits the correct exit status for remote execution with protocol version 2.
> 
> 17) ssh-keygen(1) can import private RSA/DSA keys generated with the commercial version
> 
> 18) ssh-keyscan(1) supports protocol version 2
> 
> OpenSSH is brought to you by Markus Friedl, Niels Provos, Theo de Raadt,
> Kevin Steves, Damien Miller and Ben Lindstrom.
> 

Hate to do this but BSD/OS gives us:


Script started on Tue Nov  6 17:23:15 2001
doctor.nl2k.ab.ca//usr/source/openssh-3.0p1$ make
(cd openbsd-compat; make)
gcc -o ssh ssh.o sshconnect.o sshconnect1.o sshconnect2.o sshtty.o readconf.o clientloop.o -L. -Lopenbsd-compat/ -L/usr/contrib/openssl/lib -lssh -lopenbsd-compat -lutil -lz  -lcrypto
gcc -o sshd sshd.o auth.o auth1.o auth2.o auth-chall.o auth2-chall.o auth-rhosts.o auth-options.o auth-krb4.o auth-pam.o auth2-pam.o auth-passwd.o auth-rsa.o auth-rh-rsa.o auth-sia.o sshpty.o sshlogin.o loginrec.o servconf.o serverloop.o md5crypt.o session.o groupaccess.o auth-skey.o auth-bsdauth.o -L. -Lopenbsd-compat/ -L/usr/contrib/openssl/lib -lssh -lopenbsd-compat -lutil -lz  -lcrypto
auth.o: In function `allowed_user':
/usr/source/openssh-3.0p1/auth.c:80: undefined reference to `getspnam'
*** Error code 1

Stop.
doctor.nl2k.ab.ca//usr/source/openssh-3.0p1$ gmake
(cd openbsd-compat; gmake)
gmake[1]: Entering directory `/usr/source/openssh-3.0p1/openbsd-compat'
gmake[1]: Nothing to be done for `all'.
gmake[1]: Leaving directory `/usr/source/openssh-3.0p1/openbsd-compat'
gcc -o sshd sshd.o auth.o auth1.o auth2.o auth-chall.o auth2-chall.o auth-rhosts.o auth-options.o auth-krb4.o auth-pam.o auth2-pam.o auth-passwd.o auth-rsa.o auth-rh-rsa.o auth-sia.o sshpty.o sshlogin.o loginrec.o servconf.o serverloop.o md5crypt.o session.o groupaccess.o auth-skey.o auth-bsdauth.o -L. -Lopenbsd-compat/ -L/usr/contrib/openssl/lib  -lssh -lopenbsd-compat -lutil -lz  -lcrypto 
auth.o: In function `allowed_user':
/usr/source/openssh-3.0p1/auth.c:80: undefined reference to `getspnam'
gmake: *** [sshd] Error 1
doctor.nl2k.ab.ca//usr/source/openssh-3.0p1$ egrep getspnam /usr/include/*.h
/usr/include/shadow.h:extern struct spwd *getspnam (__const char *__name) ;
/usr/include/shadow.h:extern int getspnam_r (__const char *__name, struct spwd *__result_buf,
doctor.nl2k.ab.ca//usr/source/openssh-3.0p1$ cat auth.c
/*
 * Copyright (c) 2000 Markus Friedl.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "includes.h"
RCSID("$OpenBSD: auth.c,v 1.28 2001/10/03 10:01:20 markus Exp $");

#ifdef HAVE_LOGIN_H
#include <login.h>
#endif
#include </usr/include/shadow.h>

#ifdef HAVE_LIBGEN_H
#include <libgen.h>
#endif

#include "xmalloc.h"
#include "match.h"
#include "groupaccess.h"
#include "log.h"
#include "servconf.h"
#include "auth.h"
#include "auth-options.h"
#include "canohost.h"
#include "buffer.h"
#include "bufaux.h"
#include "uidswap.h"
#include "tildexpand.h"

/* import */
extern ServerOptions options;

/*
 * Check if the user is allowed to log in via ssh. If user is listed
 * in DenyUsers or one of user's groups is listed in DenyGroups, false
 * will be returned. If AllowUsers isn't empty and user isn't listed
 * there, or if AllowGroups isn't empty and one of user's groups isn't
 * listed there, false will be returned.
 * If the user's shell is not executable, false will be returned.
 * Otherwise true is returned.
 */
int
allowed_user(struct passwd * pw)
{
        struct stat st;
        const char *hostname = NULL, *ipaddr = NULL;
        char *shell;
        int i;
#ifdef WITH_AIXAUTHENTICATE
        char *loginmsg;
#endif /* WITH_AIXAUTHENTICATE */
#if !defined(USE_PAM) && defined(HAVE_SHADOW_H) && \
        !defined(DISABLE_SHADOW) && defined(HAS_SHADOW_EXPIRE)
        struct spwd *spw;

        /* Shouldn't be called if pw is NULL, but better safe than sorry... */
        if (!pw || !pw->pw_name)
                return 0;

        spw = getspnam(pw->pw_name);
        if (spw != NULL) {
                int days = time(NULL) / 86400;

                /* Check account expiry */
                if ((spw->sp_expire >= 0) && (days > spw->sp_expire))
                        return 0;

                /* Check password expiry */
                if ((spw->sp_lstchg >= 0) && (spw->sp_max >= 0) &&
                    (days > (spw->sp_lstchg + spw->sp_max)))
                        return 0;
        }
#else
        /* Shouldn't be called if pw is NULL, but better safe than sorry... */
        if (!pw || !pw->pw_name)
                return 0;
#endif

        /*
         * Get the shell from the password data.  An empty shell field is
         * legal, and means /bin/sh.
         */
        shell = (pw->pw_shell[0] == '\0') ? _PATH_BSHELL : pw->pw_shell;

        /* deny if shell does not exists or is not executable */
        if (stat(shell, &st) != 0)
                return 0;
        if (!((st.st_mode & S_IFREG) && (st.st_mode & (S_IXOTH|S_IXUSR|S_IXGRP))))
                return 0;

        if (options.num_deny_users > 0 || options.num_allow_users > 0) {
                hostname = get_canonical_hostname(options.reverse_mapping_check);
                ipaddr = get_remote_ipaddr();
        }

        /* Return false if user is listed in DenyUsers */
        if (options.num_deny_users > 0) {
                for (i = 0; i < options.num_deny_users; i++)
                        if (match_user(pw->pw_name, hostname, ipaddr,
                            options.deny_users[i]))
                                return 0;
        }
        /* Return false if AllowUsers isn't empty and user isn't listed there */
        if (options.num_allow_users > 0) {
                for (i = 0; i < options.num_allow_users; i++)
                        if (match_user(pw->pw_name, hostname, ipaddr,
                            options.allow_users[i]))
                                break;
                /* i < options.num_allow_users iff we break for loop */
                if (i >= options.num_allow_users)
                        return 0;
        }
        if (options.num_deny_groups > 0 || options.num_allow_groups > 0) {
                /* Get the user's group access list (primary and supplementary) */
                if (ga_init(pw->pw_name, pw->pw_gid) == 0)
                        return 0;

                /* Return false if one of user's groups is listed in DenyGroups */
                if (options.num_deny_groups > 0)
                        if (ga_match(options.deny_groups,
                            options.num_deny_groups)) {
                                ga_free();
                                return 0;
                        }
                /*
                 * Return false if AllowGroups isn't empty and one of user's groups
                 * isn't listed there
                 */
                if (options.num_allow_groups > 0)
                        if (!ga_match(options.allow_groups,
                            options.num_allow_groups)) {
                                ga_free();
                                return 0;
                        }
                ga_free();
        }

#ifdef WITH_AIXAUTHENTICATE
        if (loginrestrictions(pw->pw_name, S_RLOGIN, NULL, &loginmsg) != 0) {
                if (loginmsg && *loginmsg) {
                        /* Remove embedded newlines (if any) */
                        char *p;
                        for (p = loginmsg; *p; p++) {
                                if (*p == '\n')
                                        *p = ' ';
                        }
                        /* Remove trailing newline */
                        *--p = '\0';
                        log("Login restricted for %s: %.100s", pw->pw_name, loginmsg);
                }
                return 0;
        }
#endif /* WITH_AIXAUTHENTICATE */

        /* We found no reason not to let this user try to log on... */
        return 1;
}

Authctxt *
authctxt_new(void)
{
        Authctxt *authctxt = xmalloc(sizeof(*authctxt));
        memset(authctxt, 0, sizeof(*authctxt));
        return authctxt;
}

void
auth_log(Authctxt *authctxt, int authenticated, char *method, char *info)
{
        void (*authlog) (const char *fmt,...) = verbose;
        char *authmsg;

        /* Raise logging level */
        if (authenticated == 1 ||
            !authctxt->valid ||
            authctxt->failures >= AUTH_FAIL_LOG ||
            strcmp(method, "password") == 0)
                authlog = log;

        if (authctxt->postponed)
                authmsg = "Postponed";
        else
                authmsg = authenticated ? "Accepted" : "Failed";

        authlog("%s %s for %s%.100s from %.200s port %d%s",
            authmsg,
            method,
            authctxt->valid ? "" : "illegal user ",
            authctxt->valid && authctxt->pw->pw_uid == 0 ? "ROOT" : authctxt->user,
            get_remote_ipaddr(),
            get_remote_port(),
            info);
}

/*
 * Check whether root logins are disallowed.
 */
int
auth_root_allowed(char *method)
{
        switch (options.permit_root_login) {
        case PERMIT_YES:
                return 1;
                break;
        case PERMIT_NO_PASSWD:
                if (strcmp(method, "password") != 0)
                        return 1;
                break;
        case PERMIT_FORCED_ONLY:
                if (forced_command) {
                        log("Root login accepted for forced command.");
                        return 1;
                }
                break;
        }
        log("ROOT LOGIN REFUSED FROM %.200s", get_remote_ipaddr());
        return 0;
}


/*
 * Given a template and a passwd structure, build a filename
 * by substituting % tokenised options. Currently, %% becomes '%',
 * %h becomes the home directory and %u the username.
 *
 * This returns a buffer allocated by xmalloc.
 */
char *
expand_filename(const char *filename, struct passwd *pw)
{
        Buffer buffer;
        char *file;
        const char *cp;

        /*
         * Build the filename string in the buffer by making the appropriate
         * substitutions to the given file name.
         */
        buffer_init(&buffer);
        for (cp = filename; *cp; cp++) {
                if (cp[0] == '%' && cp[1] == '%') {
                        buffer_append(&buffer, "%", 1);
                        cp++;
                        continue;
                }
                if (cp[0] == '%' && cp[1] == 'h') {
                        buffer_append(&buffer, pw->pw_dir, strlen(pw->pw_dir));
                        cp++;
                        continue;
                }
                if (cp[0] == '%' && cp[1] == 'u') {
                        buffer_append(&buffer, pw->pw_name,
                             strlen(pw->pw_name));
                        cp++;
                        continue;
                }
                buffer_append(&buffer, cp, 1);
        }
        buffer_append(&buffer, "\0", 1);

        /*
         * Ensure that filename starts anchored. If not, be backward
         * compatible and prepend the '%h/'
         */
        file = xmalloc(MAXPATHLEN);
        cp = buffer_ptr(&buffer);
        if (*cp != '/')
                snprintf(file, MAXPATHLEN, "%s/%s", pw->pw_dir, cp);
        else
                strlcpy(file, cp, MAXPATHLEN);

        buffer_free(&buffer);
        return file;
}

char *
authorized_keys_file(struct passwd *pw)
{
        return expand_filename(options.authorized_keys_file, pw);
}

char *
authorized_keys_file2(struct passwd *pw)
{
        return expand_filename(options.authorized_keys_file2, pw);
}

/* return ok if key exists in sysfile or userfile */
HostStatus
check_key_in_hostfiles(struct passwd *pw, Key *key, const char *host,
    const char *sysfile, const char *userfile)
{
        Key *found;
        char *user_hostfile;
        struct stat st;
        int host_status;

        /* Check if we know the host and its host key. */
        found = key_new(key->type);
        host_status = check_host_in_hostfile(sysfile, host, key, found, NULL);

        if (host_status != HOST_OK && userfile != NULL) {
                user_hostfile = tilde_expand_filename(userfile, pw->pw_uid);
                if (options.strict_modes &&
                    (stat(user_hostfile, &st) == 0) &&
                    ((st.st_uid != 0 && st.st_uid != pw->pw_uid) ||
                     (st.st_mode & 022) != 0)) {
                        log("Authentication refused for %.100s: "
                            "bad owner or modes for %.200s",
                            pw->pw_name, user_hostfile);
                } else {
                        temporarily_use_uid(pw);
                        host_status = check_host_in_hostfile(user_hostfile,
                            host, key, found, NULL);
                        restore_uid();
                }
                xfree(user_hostfile);
        }
        key_free(found);

        debug2("check_key_in_hostfiles: key %s for %s", host_status == HOST_OK ?
            "ok" : "not found", host);
        return host_status;
}


/*
 * Check a given file for security. This is defined as all components
 * of the path to the file must either be owned by either the owner of
 * of the file or root and no directories must be group or world writable.
 *
 * XXX Should any specific check be done for sym links ?
 *
 * Takes an open file descriptor, the file name, a uid and and
 * error buffer plus max size as arguments.
 *
 * Returns 0 on success and -1 on failure
 */
int
secure_filename(FILE *f, const char *file, struct passwd *pw,
    char *err, size_t errlen)
{
        uid_t uid = pw->pw_uid;
        char buf[MAXPATHLEN], homedir[MAXPATHLEN];
        char *cp;
        struct stat st;

        if (realpath(file, buf) == NULL) {
                snprintf(err, errlen, "realpath %s failed: %s", file,
                    strerror(errno));
                return -1;
        }
        if (realpath(pw->pw_dir, homedir) == NULL) {
                snprintf(err, errlen, "realpath %s failed: %s", pw->pw_dir,
                    strerror(errno));
                return -1;
        }

        /* check the open file to avoid races */
        if (fstat(fileno(f), &st) < 0 ||
            (st.st_uid != 0 && st.st_uid != uid) ||
            (st.st_mode & 022) != 0) {
                snprintf(err, errlen, "bad ownership or modes for file %s",
                    buf);
                return -1;
        }

        /* for each component of the canonical path, walking upwards */
        for (;;) {
                if ((cp = dirname(buf)) == NULL) {
                        snprintf(err, errlen, "dirname() failed");
                        return -1;
                }
                strlcpy(buf, cp, sizeof(buf));

                debug3("secure_filename: checking '%s'", buf);
                if (stat(buf, &st) < 0 ||
                    (st.st_uid != 0 && st.st_uid != uid) ||
                    (st.st_mode & 022) != 0) {
                        snprintf(err, errlen, 
                            "bad ownership or modes for directory %s", buf);
                        return -1;
                }

                /* If are passed the homedir then we can stop */
                if (strcmp(homedir, buf) == 0) {
                        debug3("secure_filename: terminating check at '%s'",
                            buf);
                        break;
                }
                /*
                 * dirname should always complete with a "/" path,
                 * but we can be paranoid and check for "." too
                 */
                if ((strcmp("/", buf) == 0) || (strcmp(".", buf) == 0))
                        break;
        }
        return 0;
}
doctor.nl2k.ab.ca//usr/source/openssh-3.0p1$ exit
exit

Script done on Tue Nov  6 17:23:55 2001
-- 
Member - Liberal International	On 11 Sept 2001 the WORLD was violated.
This is doctor at nl2k.ab.ca	Ici doctor at nl2k.ab.ca
Society MUST be saved! Extremists must dissolve.  
Lest we forget on 11 Nov 2001




More information about the openssh-unix-dev mailing list