/*

   Unix SMB/CIFS implementation.

   Password checking

   Copyright (C) Andrew Tridgell 1992-1998

   This program 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.

   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

*/

/* this module is for checking a username/password against a system

   password database. The SMB encrypted password support is elsewhere */

#include "includes.h"

#include "system/passwd.h"

#include "auth.h"

#undef DBGC_CLASS

#define DBGC_CLASS DBGC_AUTH

#if !defined(WITH_PAM)

static char *ths_salt;

/* This must be writable. */

static char *get_this_salt(void)

{

  return ths_salt;

}

/* We may be setting a modified version of the same

 * string, so don't free before use. */

static const char *set_this_salt(const char *newsalt)

{

  char *orig_salt = ths_salt;

  ths_salt = SMB_STRDUP(newsalt);

  SAFE_FREE(orig_salt);

  return ths_salt;

}

static char *ths_crypted;

static const char *get_this_crypted(void)

{

  if (!ths_crypted) {

    return "";

  }

  return ths_crypted;

}

static const char *set_this_crypted(const char *newcrypted)

{

  char *orig_crypted = ths_crypted;

  ths_crypted = SMB_STRDUP(newcrypted);

  SAFE_FREE(orig_crypted);

  return ths_crypted;

}

#endif

/****************************************************************************

core of password checking routine

****************************************************************************/

static NTSTATUS password_check(const char *user, const char *password, const void *private_data)

{

#ifdef WITH_PAM

  const char *rhost = (const char *)private_data;

  return smb_pam_passcheck(user, rhost, password);

#else

  bool ret;

#ifdef ULTRIX_AUTH

  ret = (strcmp((char *)crypt16(password, get_this_salt()), get_this_crypted()) == 0);

  if (ret) {

    return NT_STATUS_OK;

        } else {

    return NT_STATUS_WRONG_PASSWORD;

  }

#endif /* ULTRIX_AUTH */

#ifdef HAVE_BIGCRYPT

  ret = (strcmp(bigcrypt(password, get_this_salt()), get_this_crypted()) == 0);

        if (ret) {

    return NT_STATUS_OK;

  } else {

    return NT_STATUS_WRONG_PASSWORD;

  }

#endif /* HAVE_BIGCRYPT */

#ifndef HAVE_CRYPT

  DEBUG(1, ("Warning - no crypt available\n"));

  return NT_STATUS_LOGON_FAILURE;

#else /* HAVE_CRYPT */

  ret = (strcmp((char *)crypt(password, get_this_salt()), get_this_crypted()) == 0);

        if (ret) {

    return NT_STATUS_OK;

  } else {

    return NT_STATUS_WRONG_PASSWORD;

  }

#endif /* HAVE_CRYPT */

#endif /* WITH_PAM */

}

/****************************************************************************

CHECK if a username/password is OK

the function pointer fn() points to a function to call when a successful

match is found and is used to update the encrypted password file 

return NT_STATUS_OK on correct match, appropriate error otherwise

****************************************************************************/

NTSTATUS pass_check(const struct passwd *pass,

        const char *user,

        const char *rhost,

        const char *password,

        bool run_cracker)

{

  char *pass2 = NULL;

  NTSTATUS nt_status;

#ifdef DEBUG_PASSWORD

  DEBUG(100, ("checking user=[%s] pass=[%s]\n", user, password));

#endif

  if (!password)

    return NT_STATUS_LOGON_FAILURE;

  if ((!*password) && !lp_null_passwords())

    return NT_STATUS_LOGON_FAILURE;

#if defined(WITH_PAM) 

  /*

   * If we're using PAM we want to short-circuit all the 

   * checks below and dive straight into the PAM code.

   */

  DEBUG(4, ("pass_check: Checking (PAM) password for user %s\n", user));

#else /* Not using PAM */

  DEBUG(4, ("pass_check: Checking password for user %s\n", user));

  if (!pass) {

    DEBUG(3, ("Couldn't find user %s\n", user));

    return NT_STATUS_NO_SUCH_USER;

  }

  /* Copy into global for the convenience of looping code */

  /* Also the place to keep the 'password' no matter what

     crazy struct it started in... */

  if (set_this_crypted(pass->pw_passwd) == NULL) {

    return NT_STATUS_NO_MEMORY;

  }

  if (set_this_salt(pass->pw_passwd) == NULL) {

    return NT_STATUS_NO_MEMORY;

  }

#ifdef HAVE_GETSPNAM

  {

    struct spwd *spass;

    /* many shadow systems require you to be root to get

       the password, in most cases this should already be

       the case when this function is called, except

       perhaps for IPC password changing requests */

    spass = getspnam(pass->pw_name);

    if (spass && spass->sp_pwdp) {

      if (set_this_crypted(spass->sp_pwdp) == NULL) {

        return NT_STATUS_NO_MEMORY;

      }

      if (set_this_salt(spass->sp_pwdp) == NULL) {

        return NT_STATUS_NO_MEMORY;

      }

    }

  }

#elif defined(IA_UINFO)

  {

    /* Need to get password with SVR4.2's ia_ functions

       instead of get{sp,pw}ent functions. Required by

       UnixWare 2.x, tested on version

       2.1. (tangent@cyberport.com) */

    uinfo_t uinfo;

    if (ia_openinfo(pass->pw_name, &uinfo) != -1)

      ia_get_logpwd(uinfo, &(pass->pw_passwd));

  }

#endif

#ifdef HAVE_GETPWANAM

  {

    struct passwd_adjunct *pwret;

    pwret = getpwanam(s);

    if (pwret && pwret->pwa_passwd) {

      if (set_this_crypted(pwret->pwa_passwd) == NULL) {

        return NT_STATUS_NO_MEMORY;

      }

    }

  }

#endif

#ifdef ULTRIX_AUTH

  {

    AUTHORIZATION *ap = getauthuid(pass->pw_uid);

    if (ap) {

      if (set_this_crypted(ap->a_password) == NULL) {

        endauthent();

        return NT_STATUS_NO_MEMORY;

      }

      endauthent();

    }

  }

#endif

  if (!get_this_crypted() || !*get_this_crypted()) {

    if (!lp_null_passwords()) {

      DEBUG(2, ("Disallowing %s with null password\n",

          user));

      return NT_STATUS_LOGON_FAILURE;

    }

    if (!*password) {

      DEBUG(3,

            ("Allowing access to %s with null password\n",

             user));

      return NT_STATUS_OK;

    }

  }

#endif /* defined(WITH_PAM) */

  /* try it as it came to us */

  nt_status = password_check(user, password, (const void *)rhost);

        if NT_STATUS_IS_OK(nt_status) {

    return (nt_status);

  } else if (!NT_STATUS_EQUAL(nt_status, NT_STATUS_WRONG_PASSWORD)) {

                /* No point continuing if its not the password that's to blame (ie PAM disabled). */

                return (nt_status);

        }

  if (!run_cracker) {

    return (nt_status);

  }

  /* if the password was given to us with mixed case then we don't

   * need to proceed as we know it hasn't been case modified by the

   * client */

  if (strhasupper(password) && strhaslower(password)) {

    return nt_status;

  }

  /* make a copy of it */

  pass2 = talloc_strdup(talloc_tos(), password);

  if (!pass2) {

    return NT_STATUS_NO_MEMORY;

  }

  /* try all lowercase if it's currently all uppercase */

  if (strhasupper(pass2)) {

    if (!strlower_m(pass2)) {

      return NT_STATUS_INVALID_PARAMETER;

    }

    nt_status = password_check(user, pass2, (const void *)rhost);

    if (NT_STATUS_IS_OK(nt_status)) {

      return (nt_status);

    }

  }

  return NT_STATUS_WRONG_PASSWORD;

}