�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2F'>httpd-2.4.63</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fsupport%2F'>support</a>/</p><hr><h3>✏️ Editing: htpasswd.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the &quot;License&quot;); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an &quot;AS IS&quot; BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/******************************************************************************
 ******************************************************************************
 * NOTE! This program is not safe as a setuid executable!  Do not make it
 * setuid!
 ******************************************************************************
 *****************************************************************************/
/*
 * htpasswd.c: simple program for manipulating password file for
 * the Apache HTTP server
 *
 * Originally by Rob McCool
 *
 * Exit values:
 *  0: Success
 *  1: Failure; file access/permission problem
 *  2: Failure; command line syntax problem (usage message issued)
 *  3: Failure; password verification failure
 *  4: Failure; operation interrupted (such as with CTRL/C)
 *  5: Failure; buffer would overflow (username, filename, or computed
 *     record too long)
 *  6: Failure; username contains illegal or reserved characters
 *  7: Failure; file is not a valid htpasswd file
 */

#include &quot;passwd_common.h&quot;
#include &quot;apr_signal.h&quot;
#include &quot;apr_getopt.h&quot;

#if APR_HAVE_STDIO_H
#include &lt;stdio.h&gt;
#endif

#include &quot;apr_md5.h&quot;
#include &quot;apr_sha1.h&quot;

#if APR_HAVE_STDLIB_H
#include &lt;stdlib.h&gt;
#endif
#if APR_HAVE_STRING_H
#include &lt;string.h&gt;
#endif
#if APR_HAVE_UNISTD_H
#include &lt;unistd.h&gt;
#endif

#ifdef WIN32
#include &lt;conio.h&gt;
#define unlink _unlink
#endif

#define APHTP_NEWFILE        1
#define APHTP_NOFILE         2
#define APHTP_DELUSER        4
#define APHTP_VERIFY         8

apr_file_t *ftemp = NULL;

static int mkrecord(struct passwd_ctx *ctx, char *user)
{
    char hash_str[MAX_STRING_LEN];
    int ret;

    ctx-&gt;out = hash_str;
    ctx-&gt;out_len = sizeof(hash_str);

    ret = mkhash(ctx);
    if (ret) {
        ctx-&gt;out = NULL;
        ctx-&gt;out_len = 0;
        return ret;
    }

    ctx-&gt;out = apr_pstrcat(ctx-&gt;pool, user, &quot;:&quot;, hash_str, NL, NULL);
    ctx-&gt;out_len = strlen(ctx-&gt;out);
    if (ctx-&gt;out_len &gt;= MAX_STRING_LEN) {
        ctx-&gt;errstr = &quot;resultant record too long&quot;;
        return ERR_OVERFLOW;
    }
    return 0;
}

static void usage(void)
{
    apr_file_printf(errfile, &quot;Usage:&quot; NL
        &quot;\thtpasswd [-cimB25dpsDv] [-C cost] [-r rounds] passwordfile username&quot; NL
        &quot;\thtpasswd -b[cmB25dpsDv] [-C cost] [-r rounds] passwordfile username password&quot; NL
        NL
        &quot;\thtpasswd -n[imB25dps] [-C cost] [-r rounds] username&quot; NL
        &quot;\thtpasswd -nb[mB25dps] [-C cost] [-r rounds] username password&quot; NL
        &quot; -c  Create a new file.&quot; NL
        &quot; -n  Don&#039;t update file; display results on stdout.&quot; NL
        &quot; -b  Use the password from the command line rather than prompting &quot;
            &quot;for it.&quot; NL
        &quot; -i  Read password from stdin without verification (for script usage).&quot; NL
        &quot; -m  Force MD5 hashing of the password (default).&quot; NL
        &quot; -2  Force SHA-256 hashing of the password (secure).&quot; NL
        &quot; -5  Force SHA-512 hashing of the password (secure).&quot; NL
        &quot; -B  Force bcrypt hashing of the password (very secure).&quot; NL
        &quot; -C  Set the computing time used for the bcrypt algorithm&quot; NL
        &quot;     (higher is more secure but slower, default: %d, valid: 4 to 17).&quot; NL
        &quot; -r  Set the number of rounds used for the SHA-256, SHA-512 algorithms&quot; NL
        &quot;     (higher is more secure but slower, default: 5000).&quot; NL
        &quot; -d  Force CRYPT hashing of the password (8 chars max, insecure).&quot; NL
        &quot; -s  Force SHA-1 hashing of the password (insecure).&quot; NL
        &quot; -p  Do not hash the password (plaintext, insecure).&quot; NL
        &quot; -D  Delete the specified user.&quot; NL
        &quot; -v  Verify password for the specified user.&quot; NL
        &quot;On other systems than Windows and NetWare the &#039;-p&#039; flag will &quot;
            &quot;probably not work.&quot; NL
        &quot;The SHA-1 algorithm does not use a salt and is less secure than the &quot;
            &quot;MD5 algorithm.&quot; NL,
        BCRYPT_DEFAULT_COST
    );
    exit(ERR_SYNTAX);
}

/*
 * Check to see if the specified file can be opened for the given
 * access.
 */
static int accessible(apr_pool_t *pool, char *fname, int mode)
{
    apr_file_t *f = NULL;

    if (apr_file_open(&amp;f, fname, mode, APR_OS_DEFAULT, pool) != APR_SUCCESS) {
        return 0;
    }
    apr_file_close(f);
    return 1;
}

/*
 * Return true if the named file exists, regardless of permissions.
 */
static int exists(char *fname, apr_pool_t *pool)
{
    apr_finfo_t sbuf;
    apr_status_t check;

    check = apr_stat(&amp;sbuf, fname, APR_FINFO_TYPE, pool);
    return ((check || sbuf.filetype != APR_REG) ? 0 : 1);
}

static void terminate(void)
{
    apr_terminate();
#ifdef NETWARE
    pressanykey();
#endif
}

static void check_args(int argc, const char *const argv[],
                       struct passwd_ctx *ctx, unsigned *mask, char **user,
                       char **pwfilename)
{
    const char *arg;
    int args_left = 2;
    int i, ret;
    apr_getopt_t *state;
    apr_status_t rv;
    char opt;
    const char *opt_arg;
    apr_pool_t *pool = ctx-&gt;pool;

    rv = apr_getopt_init(&amp;state, pool, argc, argv);
    if (rv != APR_SUCCESS)
        exit(ERR_SYNTAX);

    while ((rv = apr_getopt(state, &quot;cnmspdBbDi25C:r:v&quot;, &amp;opt, &amp;opt_arg)) == APR_SUCCESS) {
        switch (opt) {
        case &#039;c&#039;:
            *mask |= APHTP_NEWFILE;
            break;
        case &#039;n&#039;:
            args_left--;
            *mask |= APHTP_NOFILE;
            break;
        case &#039;D&#039;:
            *mask |= APHTP_DELUSER;
            break;
        case &#039;v&#039;:
            *mask |= APHTP_VERIFY;
            break;
        default:
            ret = parse_common_options(ctx, opt, opt_arg);
            if (ret) {
                apr_file_printf(errfile, &quot;%s: %s&quot; NL, argv[0], ctx-&gt;errstr);
                exit(ret);
            }
        }
    }
    if (ctx-&gt;passwd_src == PW_ARG)
        args_left++;
    if (rv != APR_EOF)
        usage();

    if ((*mask) &amp; (*mask - 1)) {
        /* not a power of two, i.e. more than one flag specified */
        apr_file_printf(errfile, &quot;%s: only one of -c -n -v -D may be specified&quot; NL,
            argv[0]);
        exit(ERR_SYNTAX);
    }
    if ((*mask &amp; APHTP_VERIFY) &amp;&amp; ctx-&gt;passwd_src == PW_PROMPT)
        ctx-&gt;passwd_src = PW_PROMPT_VERIFY;

    /*
     * Make sure we still have exactly the right number of arguments left
     * (the filename, the username, and possibly the password if -b was
     * specified).
     */
    i = state-&gt;ind;
    if ((argc - i) != args_left) {
        usage();
    }

    if (!(*mask &amp; APHTP_NOFILE)) {
        if (strlen(argv[i]) &gt; (APR_PATH_MAX - 1)) {
            apr_file_printf(errfile, &quot;%s: filename too long&quot; NL, argv[0]);
            exit(ERR_OVERFLOW);
        }
        *pwfilename = apr_pstrdup(pool, argv[i++]);
    }
    if (strlen(argv[i]) &gt; (MAX_STRING_LEN - 1)) {
        apr_file_printf(errfile, &quot;%s: username too long (&gt; %d)&quot; NL,
                        argv[0], MAX_STRING_LEN - 1);
        exit(ERR_OVERFLOW);
    }
    *user = apr_pstrdup(pool, argv[i++]);
    if ((arg = strchr(*user, &#039;:&#039;)) != NULL) {
        apr_file_printf(errfile, &quot;%s: username contains illegal &quot;
                        &quot;character &#039;%c&#039;&quot; NL, argv[0], *arg);
        exit(ERR_BADUSER);
    }
    if (ctx-&gt;passwd_src == PW_ARG) {
        if (strlen(argv[i]) &gt; (MAX_STRING_LEN - 1)) {
            apr_file_printf(errfile, &quot;%s: password too long (&gt; %d)&quot; NL,
                argv[0], MAX_STRING_LEN);
            exit(ERR_OVERFLOW);
        }
        ctx-&gt;passwd = apr_pstrdup(pool, argv[i]);
    }
}

static int verify(struct passwd_ctx *ctx, const char *hash)
{
    apr_status_t rv;
    int ret;

    if (ctx-&gt;passwd == NULL &amp;&amp; (ret = get_password(ctx)) != 0)
       return ret;
    rv = apr_password_validate(ctx-&gt;passwd, hash);
    if (rv == APR_SUCCESS)
        return 0;
    if (APR_STATUS_IS_EMISMATCH(rv)) {
        ctx-&gt;errstr = &quot;password verification failed&quot;;
        return ERR_PWMISMATCH;
    }
    ctx-&gt;errstr = apr_psprintf(ctx-&gt;pool, &quot;Could not verify password: %pm&quot;,
                               &amp;rv);
    return ERR_GENERAL;
}

/*
 * Let&#039;s do it.  We end up doing a lot of file opening and closing,
 * but what do we care?  This application isn&#039;t run constantly.
 */
int main(int argc, const char * const argv[])
{
    apr_file_t *fpw = NULL;
    char line[MAX_STRING_LEN];
    char *pwfilename = NULL;
    char *user = NULL;
    char tn[] = &quot;htpasswd.tmp.XXXXXX&quot;;
    char *dirname;
    char *scratch, cp[MAX_STRING_LEN];
    int found = 0;
    int i;
    unsigned mask = 0;
    apr_pool_t *pool;
    int existing_file = 0;
    struct passwd_ctx ctx = { 0 };
#if APR_CHARSET_EBCDIC
    apr_status_t rv;
    apr_xlate_t *to_ascii;
#endif

    apr_app_initialize(&amp;argc, &amp;argv, NULL);
    atexit(terminate);
    apr_pool_create(&amp;pool, NULL);
    apr_pool_abort_set(abort_on_oom, pool);
    apr_file_open_stderr(&amp;errfile, pool);
    ctx.pool = pool;
    ctx.alg = ALG_APMD5;

#if APR_CHARSET_EBCDIC
    rv = apr_xlate_open(&amp;to_ascii, &quot;ISO-8859-1&quot;, APR_DEFAULT_CHARSET, pool);
    if (rv) {
        apr_file_printf(errfile, &quot;apr_xlate_open(to ASCII)-&gt;%d&quot; NL, rv);
        exit(1);
    }
    rv = apr_SHA1InitEBCDIC(to_ascii);
    if (rv) {
        apr_file_printf(errfile, &quot;apr_SHA1InitEBCDIC()-&gt;%d&quot; NL, rv);
        exit(1);
    }
    rv = apr_MD5InitEBCDIC(to_ascii);
    if (rv) {
        apr_file_printf(errfile, &quot;apr_MD5InitEBCDIC()-&gt;%d&quot; NL, rv);
        exit(1);
    }
#endif /*APR_CHARSET_EBCDIC*/

    check_args(argc, argv, &amp;ctx, &amp;mask, &amp;user, &amp;pwfilename);

    /*
     * Only do the file checks if we&#039;re supposed to frob it.
     */
    if (!(mask &amp; APHTP_NOFILE)) {
        existing_file = exists(pwfilename, pool);
        if (existing_file &amp;&amp; (mask &amp; APHTP_VERIFY) == 0) {
            /*
             * Check that this existing file is readable and writable.
             */
            if (!accessible(pool, pwfilename, APR_FOPEN_READ|APR_FOPEN_WRITE)) {
                apr_file_printf(errfile, &quot;%s: cannot open file %s for &quot;
                                &quot;read/write access&quot; NL, argv[0], pwfilename);
                exit(ERR_FILEPERM);
            }
        }
        else if (existing_file &amp;&amp; (mask &amp; APHTP_VERIFY) != 0) {
            /*
             * Check that this existing file is readable.
             */
            if (!accessible(pool, pwfilename, APR_FOPEN_READ)) {
                apr_file_printf(errfile, &quot;%s: cannot open file %s for &quot;
                                &quot;read access&quot; NL, argv[0], pwfilename);
                exit(ERR_FILEPERM);
            }
        }
        else {
            /*
             * Error out if -c was omitted for this non-existent file.
             */
            if (!(mask &amp; APHTP_NEWFILE)) {
                apr_file_printf(errfile,
                        &quot;%s: cannot modify file %s; use &#039;-c&#039; to create it&quot; NL,
                        argv[0], pwfilename);
                exit(ERR_FILEPERM);
            }
            /*
             * As it doesn&#039;t exist yet, verify that we can create it.
             */
            if (!accessible(pool, pwfilename, APR_FOPEN_WRITE|APR_FOPEN_CREATE)) {
                apr_file_printf(errfile, &quot;%s: cannot create file %s&quot; NL,
                                argv[0], pwfilename);
                exit(ERR_FILEPERM);
            }
        }
    }

    /*
     * All the file access checks (if any) have been made.  Time to go to work;
     * try to create the record for the username in question.  If that
     * fails, there&#039;s no need to waste any time on file manipulations.
     * Any error message text is returned in the record buffer, since
     * the mkrecord() routine doesn&#039;t have access to argv[].
     */
    if ((mask &amp; (APHTP_DELUSER|APHTP_VERIFY)) == 0) {
        i = mkrecord(&amp;ctx, user);
        if (i != 0) {
            apr_file_printf(errfile, &quot;%s: %s&quot; NL, argv[0], ctx.errstr);
            exit(i);
        }
        if (mask &amp; APHTP_NOFILE) {
            printf(&quot;%s&quot; NL, ctx.out);
            exit(0);
        }
    }

    if ((mask &amp; APHTP_VERIFY) == 0) {
        /*
         * We can access the files the right way, and we have a record
         * to add or update.  Let&#039;s do it..
         */
        if (apr_temp_dir_get((const char**)&amp;dirname, pool) != APR_SUCCESS) {
            apr_file_printf(errfile, &quot;%s: could not determine temp dir&quot; NL,
                            argv[0]);
            exit(ERR_FILEPERM);
        }
        dirname = apr_psprintf(pool, &quot;%s/%s&quot;, dirname, tn);

        if (apr_file_mktemp(&amp;ftemp, dirname, 0, pool) != APR_SUCCESS) {
            apr_file_printf(errfile, &quot;%s: unable to create temporary file %s&quot; NL,
                            argv[0], dirname);
            exit(ERR_FILEPERM);
        }
    }

    /*
     * If we&#039;re not creating a new file, copy records from the existing
     * one to the temporary file until we find the specified user.
     */
    if (existing_file &amp;&amp; !(mask &amp; APHTP_NEWFILE)) {
        if (apr_file_open(&amp;fpw, pwfilename, APR_READ | APR_BUFFERED,
                          APR_OS_DEFAULT, pool) != APR_SUCCESS) {
            apr_file_printf(errfile, &quot;%s: unable to read file %s&quot; NL,
                            argv[0], pwfilename);
            exit(ERR_FILEPERM);
        }
        while (apr_file_gets(line, sizeof(line), fpw) == APR_SUCCESS) {
            char *colon;

            strcpy(cp, line);
            scratch = cp;
            while (apr_isspace(*scratch)) {
                ++scratch;
            }

            if (!*scratch || (*scratch == &#039;#&#039;)) {
                putline(ftemp, line);
                continue;
            }
            /*
             * See if this is our user.
             */
            colon = strchr(scratch, &#039;:&#039;);
            if (colon != NULL) {
                *colon = &#039;\0&#039;;
            }
            else {
                /*
                 * If we&#039;ve not got a colon on the line, this could well
                 * not be a valid htpasswd file.
                 * We should bail at this point.
                 */
                apr_file_printf(errfile, &quot;%s: The file %s does not appear &quot;
                                         &quot;to be a valid htpasswd file.&quot; NL,
                                argv[0], pwfilename);
                apr_file_close(fpw);
                exit(ERR_INVALID);
            }
            if (strcmp(user, scratch) != 0) {
                putline(ftemp, line);
                continue;
            }
            else {
                /* We found the user we were looking for */
                found++;
                if ((mask &amp; APHTP_DELUSER)) {
                    /* Delete entry from the file */
                    apr_file_printf(errfile, &quot;Deleting &quot;);
                }
                else if ((mask &amp; APHTP_VERIFY)) {
                    /* Verify */
                    char *hash = colon + 1;
                    size_t len;

                    len = strcspn(hash, &quot;\r\n&quot;);
                    if (len == 0) {
                        apr_file_printf(errfile, &quot;Empty hash for user %s&quot; NL,
                                        user);
                        exit(ERR_INVALID);
                    }
                    hash[len] = &#039;\0&#039;;

                    i = verify(&amp;ctx, hash);
                    if (i != 0) {
                        apr_file_printf(errfile, &quot;%s&quot; NL, ctx.errstr);
                        exit(i);
                    }
                }
                else {
                    /* Update entry */
                    apr_file_printf(errfile, &quot;Updating &quot;);
                    putline(ftemp, ctx.out);
                }
            }
        }
        apr_file_close(fpw);
    }
    if (!found) {
        if (mask &amp; APHTP_DELUSER) {
            apr_file_printf(errfile, &quot;User %s not found&quot; NL, user);
            exit(0);
        }
        else if (mask &amp; APHTP_VERIFY) {
            apr_file_printf(errfile, &quot;User %s not found&quot; NL, user);
            exit(ERR_BADUSER);
        }
        else {
            apr_file_printf(errfile, &quot;Adding &quot;);
            putline(ftemp, ctx.out);
        }
    }
    if (mask &amp; APHTP_VERIFY) {
        apr_file_printf(errfile, &quot;Password for user %s correct.&quot; NL, user);
        exit(0);
    }

    apr_file_printf(errfile, &quot;password for user %s&quot; NL, user);

    /* The temporary file has all the data, just copy it to the new location.
     */
    if (apr_file_copy(dirname, pwfilename, APR_OS_DEFAULT, pool) !=
        APR_SUCCESS) {
        apr_file_printf(errfile, &quot;%s: unable to update file %s&quot; NL,
                        argv[0], pwfilename);
        exit(ERR_FILEPERM);
    }
    apr_file_close(ftemp);
    return 0;
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fsupport'>🔙 Back</a></p>