HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/home/pam_systemd_home.c

54,970 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: e4177092674ab1fcf3d8232a99209892af63f1ca

Lines 1001–1213 of 1,213

                return r;
 
        r = acquire_user_record(pamh, /* username= */ NULL, debug, &ur, /* bus_data= */ NULL);
        if (r != PAM_SUCCESS)
                return r;
 
        r = user_record_test_blocked(ur);
        switch (r) {
 
        case -ESTALE:
                sym_pam_syslog(pamh, LOG_WARNING, "User record for '%s' is newer than current system time, assuming incorrect system clock, allowing access.", ur->user_name);
                break;
 
        case -ENOLCK:
                (void) pam_prompt_graceful(pamh, PAM_ERROR_MSG, NULL, _("User record is blocked, prohibiting access."));
                return PAM_ACCT_EXPIRED;
 
        case -EL2HLT:
                (void) pam_prompt_graceful(pamh, PAM_ERROR_MSG, NULL, _("User record is not valid yet, prohibiting access."));
                return PAM_ACCT_EXPIRED;
 
        case -EL3HLT:
                (void) pam_prompt_graceful(pamh, PAM_ERROR_MSG, NULL, _("User record is not valid anymore, prohibiting access."));
                return PAM_ACCT_EXPIRED;
 
        default:
                if (r < 0) {
                        (void) pam_prompt_graceful(pamh, PAM_ERROR_MSG, NULL, _("User record not valid, prohibiting access."));
                        return PAM_ACCT_EXPIRED;
                }
        }
 
        t = user_record_ratelimit_next_try(ur);
        if (t != USEC_INFINITY) {
                usec_t n = now(CLOCK_REALTIME);
 
                if (t > n) {
                        (void) pam_prompt_graceful(pamh, PAM_ERROR_MSG, NULL, _("Too many logins, try again in %s."),
                                          FORMAT_TIMESPAN(t - n, USEC_PER_SEC));
 
                        return PAM_MAXTRIES;
                }
        }
 
        r = user_record_test_password_change_required(ur);
        switch (r) {
 
        case -EKEYREVOKED:
                (void) pam_prompt_graceful(pamh, PAM_ERROR_MSG, NULL, _("Password change required."));
                return PAM_NEW_AUTHTOK_REQD;
 
        case -EOWNERDEAD:
                (void) pam_prompt_graceful(pamh, PAM_ERROR_MSG, NULL, _("Password expired, change required."));
                return PAM_NEW_AUTHTOK_REQD;
 
        /* Strictly speaking this is only about password expiration, and we might want to allow
         * authentication via PKCS#11 or so, but let's ignore this fine distinction for now. */
        case -EKEYREJECTED:
                (void) pam_prompt_graceful(pamh, PAM_ERROR_MSG, NULL, _("Password is expired, but can't change, refusing login."));
                return PAM_AUTHTOK_EXPIRED;
 
        case -EKEYEXPIRED:
                (void) pam_prompt_graceful(pamh, PAM_ERROR_MSG, NULL, _("Password will expire soon, please change."));
                break;
 
        case -ESTALE:
                /* If the system clock is wrong, let's log but continue */
                sym_pam_syslog(pamh, LOG_WARNING, "Couldn't check if password change is required, last change is in the future, system clock likely wrong.");
                break;
 
        case -EROFS:
                /* All good, just means the password if we wanted to change we couldn't, but we don't need to */
                break;
 
        default:
                if (r < 0) {
                        (void) pam_prompt_graceful(pamh, PAM_ERROR_MSG, NULL, _("User record not valid, prohibiting access."));
                        return PAM_AUTHTOK_EXPIRED;
                }
        }
 
        return PAM_SUCCESS;
}
 
_public_ PAM_EXTERN int pam_sm_chauthtok(
                pam_handle_t *pamh,
                int sm_flags,
                int argc,
                const char **argv) {
 
        _cleanup_(user_record_unrefp) UserRecord *ur = NULL, *old_secret = NULL, *new_secret = NULL;
        const char *old_password = NULL, *new_password = NULL;
        unsigned n_attempts = 0;
        bool debug = false;
        int r;
 
        r = dlopen_libpam(LOG_DEBUG);
        if (r < 0)
                return PAM_SERVICE_ERR;
 
        pam_log_setup();
 
        if (parse_argv(pamh,
                       argc, argv,
                       NULL,
                       &debug) < 0)
                return PAM_AUTH_ERR;
 
        pam_debug_syslog(pamh, debug, "pam-systemd-homed: starting authentication token management...");
 
        r = acquire_user_record(pamh, /* username= */ NULL, debug, &ur, /* bus_data= */ NULL);
        if (r != PAM_SUCCESS)
                return r;
 
        /* Start with cached credentials */
        r = pam_get_item_many(
                        pamh,
                        PAM_OLDAUTHTOK, &old_password,
                        PAM_AUTHTOK, &new_password);
        if (r != PAM_SUCCESS)
                return pam_syslog_pam_error(pamh, LOG_ERR, r, "Failed to get cached passwords: @PAMERR@");
 
        if (isempty(new_password)) {
                /* No, it's not cached, then let's ask for the password and its verification, and cache
                 * it. */
 
                r = sym_pam_get_authtok_noverify(pamh, &new_password, "New password: ");
                if (r != PAM_SUCCESS)
                        return pam_syslog_pam_error(pamh, LOG_ERR, r, "Failed to get new password: @PAMERR@");
 
                if (isempty(new_password)) {
                        pam_debug_syslog(pamh, debug, "Password request aborted.");
                        return PAM_AUTHTOK_ERR;
                }
 
                r = sym_pam_get_authtok_verify(pamh, &new_password, "new password: "); /* Lower case, since PAM prefixes 'Repeat' */
                if (r != PAM_SUCCESS)
                        return pam_syslog_pam_error(pamh, LOG_ERR, r, "Failed to get password again: @PAMERR@");
 
                // FIXME: pam_pwquality will ask for the password a third time. It really shouldn't do
                // that, and instead assume the password was already verified once when it is found to be
                // cached already. needs to be fixed in pam_pwquality
        }
 
        /* Now everything is cached and checked, let's exit from the preliminary check */
        if (FLAGS_SET(sm_flags, PAM_PRELIM_CHECK))
                return PAM_SUCCESS;
 
        old_secret = user_record_new();
        if (!old_secret)
                return pam_log_oom(pamh);
 
        if (!isempty(old_password)) {
                r = user_record_set_password(old_secret, STRV_MAKE(old_password), true);
                if (r < 0)
                        return pam_syslog_errno(pamh, LOG_ERR, r, "Failed to store old password: %m");
        }
 
        new_secret = user_record_new();
        if (!new_secret)
                return pam_log_oom(pamh);
 
        r = user_record_set_password(new_secret, STRV_MAKE(new_password), true);
        if (r < 0)
                return pam_syslog_errno(pamh, LOG_ERR, r, "Failed to store new password: %m");
 
        _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
        r = pam_acquire_bus_connection(pamh, "pam-systemd-home", debug, &bus, NULL);
        if (r != PAM_SUCCESS)
                return r;
 
        for (;;) {
                _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
                _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 
                r = bus_message_new_method_call(bus, &m, bus_home_mgr, "ChangePasswordHome");
                if (r < 0)
                        return pam_bus_log_create_error(pamh, r);
 
                r = sd_bus_message_append(m, "s", ur->user_name);
                if (r < 0)
                        return pam_bus_log_create_error(pamh, r);
 
                r = bus_message_append_secret(m, new_secret);
                if (r < 0)
                        return pam_bus_log_create_error(pamh, r);
 
                r = bus_message_append_secret(m, old_secret);
                if (r < 0)
                        return pam_bus_log_create_error(pamh, r);
 
                r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
                if (r < 0) {
                        r = handle_generic_user_record_error(pamh, ur->user_name, old_secret, r, &error, debug);
                        if (r == PAM_CONV_ERR)
                                return pam_syslog_pam_error(pamh, LOG_ERR, r,
                                                            "Failed to prompt for password/prompt.");
                        if (r != PAM_SUCCESS)
                                return r;
                } else
                        return pam_syslog_pam_error(pamh, LOG_NOTICE, PAM_SUCCESS,
                                                    "Successfully changed password for user %s.", ur->user_name);
 
                if (++n_attempts >= 5)
                        break;
 
                /* Try again */
        };
 
        return pam_syslog_pam_error(pamh, LOG_NOTICE, PAM_MAXTRIES,
                                    "Failed to change password for user %s: @PAMERR@", ur->user_name);
}