/*
 * encode_keychange.c
 *
 * Collect information to build a KeyChange encoding, per the textual
 * convention given in RFC 2274, Section 5.  Compute the value and
 * dump to stdout as a string of hex nibbles.
 *
 *
 * Passphrase material may come from many sources.  The following are
 * checked in order (see get_user_passphrases()):
 *      - Prompt always if -f is given.
 *      - Commandline arguments.
 *      - PASSPHRASE_FILE.
 *      - Prompts on stdout.   Use -P to turn off prompt tags.
 *
 *
 * FIX  Better name?
 * FIX  Change encode_keychange() to take random bits?
 * FIX  QUITFUN not quite appropriate here...
 * FIX  This is slow...
 */

#include <net-snmp/net-snmp-config.h>

#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif

#include <net-snmp/net-snmp-includes.h>

#include <stdlib.h>

/*
 * Globals, &c...
 */
char           *local_progname;
char           *local_passphrase_filename;

#define NL	"\n"

#define USAGE	"Usage: %s [-fhPvV] -t (md5|sha1) [-O \"<old_passphrase>\"][-N \"<new_passphrase>\"][-E [0x]<engineID>]"

#define OPTIONLIST	"E:fhN:O:Pt:vVD"

#define PASSPHRASE_DIR		".snmp"
        /*
         * Rooted at $HOME.
         */
#define PASSPHRASE_FILE		"passphrase.ek"
        /*
         * Format: two lines containing old and new passphrases, nothing more.
         *      
         * XXX  Add creature comforts like: comments and 
         *      tokens identifying passphrases, separate directory check,
         *      check in current directory (?), traverse a path of
         *      directories (?)...
         * FIX  Better name?
         */


int             forcepassphrase = 0,    /* Always prompt for passphrases. */
                promptindicator = 1,    /* Output an indicator that input
                                         *   is requested.                */
                visible = 0,    /* Echo passphrases to terminal.  */
                verbose = 0;    /* Output progress to stderr.     */
size_t          engineid_len = 0;

u_char         *engineid = NULL;        /* Both input & final binary form. */
char           *newpass = NULL, *oldpass = NULL;

char           *transform_type_input = NULL;

const oid      *transform_type = NULL;  /* Type of HMAC hash to use.      */
size_t          transform_type_len = 0;


/*
 * Prototypes.
 */
void            usage_to_file(FILE * ofp);
void            usage_synopsis(FILE * ofp);
int             get_user_passphrases(void);
int             snmp_ttyecho(const int fd, const int echo);
char           *snmp_getpassphrase(const char *prompt, int fvisible);

#if defined(HAVE__CPUTS) && defined(HAVE__GETCH)
#include <conio.h>
#include <io.h>
#define HAVE_GETPASS 1
#define isatty _isatty
static char    *getpass(const char *prompt);
#endif

/*******************************************************************-o-******
 */
int
main(int argc, char **argv)
{
    int             rval = 1;
    size_t          oldKu_len = SNMP_MAXBUF_SMALL,
        newKu_len = SNMP_MAXBUF_SMALL,
        oldkul_len = SNMP_MAXBUF_SMALL,
        newkul_len = SNMP_MAXBUF_SMALL, keychange_len = SNMP_MAXBUF_SMALL;

    char           *s = NULL;
    u_char          oldKu[SNMP_MAXBUF_SMALL],
        newKu[SNMP_MAXBUF_SMALL],
        oldkul[SNMP_MAXBUF_SMALL],
        newkul[SNMP_MAXBUF_SMALL], keychange[SNMP_MAXBUF_SMALL];

    int             i, auth_type;
    int             arg = 1;

    local_progname = argv[0];
    local_passphrase_filename = (char *) malloc(sizeof(PASSPHRASE_DIR) +
                                                sizeof(PASSPHRASE_FILE) +
                                                4);
    if (!local_passphrase_filename) {
        fprintf(stderr, "%s: out of memory!", local_progname);
        exit(-1);
    }
    sprintf(local_passphrase_filename, "%s/%s", PASSPHRASE_DIR,
            PASSPHRASE_FILE);



    /*
     * Parse.
     */
    for (; (arg < argc) && (argv[arg][0] == '-'); arg++) {
        switch (argv[arg][1]) {
        case 'D':
            snmp_set_do_debugging(1);
            break;
        case 'E':
            engineid = (u_char *) argv[++arg];
            break;
        case 'f':
            forcepassphrase = 1;
            break;
        case 'N':
            newpass = argv[++arg];
            break;
        case 'O':
            oldpass = argv[++arg];
            break;
        case 'P':
            promptindicator = 0;
            break;
        case 't':
            transform_type_input = argv[++arg];
            break;
        case 'v':
            verbose = 1;
            break;
        case 'V':
            visible = 1;
            break;
        case 'h':
            rval = 0;
	    /* fallthrough */
        default:
            usage_to_file(stdout);
            exit(rval);
        }
    }

    if (!transform_type_input) {
        fprintf(stderr, "The -t option is mandatory.\n");
        usage_synopsis(stdout);
        exit(1000);
    }



    /*
     * Convert and error check transform_type.
     */
    auth_type = usm_lookup_auth_type(transform_type_input);
    transform_type = sc_get_auth_oid( auth_type, &transform_type_len );
    if (NULL == transform_type) {
        fprintf(stderr,
                "Unrecognized hash transform: \"%s\".\n",
                transform_type_input);
        usage_synopsis(stderr);
        QUITFUN(SNMPERR_GENERR, main_quit);
    }

    if (verbose) {
        fprintf(stderr, "Hash:\t\t%s\n", sc_get_auth_name(auth_type));
    }



    /*
     * Build engineID.  Accept hex engineID as the bits
     * "in-and-of-themselves", otherwise create an engineID with the
     * given string as text.
     *
     * If no engineID is given, lookup the first IP address for the
     * localhost and use that (see setup_engineID()).
     */
    if (engineid && (tolower(*(engineid + 1)) == 'x')) {
        engineid_len = hex_to_binary2(engineid + 2,
                                      strlen((char *) engineid) - 2,
                                      (char **) &engineid);
        DEBUGMSGTL(("encode_keychange", "engineIDLen: %lu\n",
                    (unsigned long)engineid_len));
    } else {
        engineid_len = setup_engineID(&engineid, (char *) engineid);
        if ((ssize_t)engineid_len < 0)
            exit(1);
    }

#ifdef NETSNMP_ENABLE_TESTING_CODE
    if (verbose) {
        fprintf(stderr, "EngineID:\t%s\n",
                /*
                 * XXX = 
                 */ dump_snmpEngineID(engineid, &engineid_len));
    }
#endif


    /*
     * Get passphrases from user.
     */
    rval = get_user_passphrases();
    QUITFUN(rval, main_quit);

    if (strlen(oldpass) < USM_LENGTH_P_MIN) {
        fprintf(stderr, "Old passphrase must be greater than %d "
                "characters in length.\n", USM_LENGTH_P_MIN);
        QUITFUN(SNMPERR_GENERR, main_quit);

    } else if (strlen(newpass) < USM_LENGTH_P_MIN) {
        fprintf(stderr, "New passphrase must be greater than %d "
                "characters in length.\n", USM_LENGTH_P_MIN);
        QUITFUN(SNMPERR_GENERR, main_quit);
    }

    if (verbose) {
        fprintf(stderr,
                "Old passphrase:\t%s\nNew passphrase:\t%s\n",
                oldpass, newpass);
    }



    /*
     * Compute Ku and Kul's from old and new passphrases, then
     * compute the keychange string & print it out.
     */
    rval = sc_init();
    QUITFUN(rval, main_quit);


    rval = generate_Ku(transform_type, transform_type_len,
                       (u_char *) oldpass, strlen(oldpass),
                       oldKu, &oldKu_len);
    QUITFUN(rval, main_quit);


    rval = generate_Ku(transform_type, transform_type_len,
                       (u_char *) newpass, strlen(newpass),
                       newKu, &newKu_len);
    QUITFUN(rval, main_quit);


    DEBUGMSGTL(("encode_keychange", "EID (%lu): ", (unsigned long)engineid_len));
    for (i = 0; i < (int) engineid_len; i++)
        DEBUGMSGTL(("encode_keychange", "%02x", (int) (engineid[i])));
    DEBUGMSGTL(("encode_keychange", "\n"));

    DEBUGMSGTL(("encode_keychange", "old Ku (%lu) (from %s): ", (unsigned long)oldKu_len,
                oldpass));
    for (i = 0; i < (int) oldKu_len; i++)
        DEBUGMSGTL(("encode_keychange", "%02x", (int) (oldKu[i])));
    DEBUGMSGTL(("encode_keychange", "\n"));

    rval = generate_kul(transform_type, transform_type_len,
                        engineid, engineid_len,
                        oldKu, oldKu_len, oldkul, &oldkul_len);
    QUITFUN(rval, main_quit);


    DEBUGMSGTL(("encode_keychange", "generating old Kul (%lu) (from Ku): ",
                (unsigned long)oldkul_len));
    for (i = 0; i < (int) oldkul_len; i++)
        DEBUGMSGTL(("encode_keychange", "%02x", (int) (oldkul[i])));
    DEBUGMSGTL(("encode_keychange", "\n"));

    rval = generate_kul(transform_type, transform_type_len,
                        engineid, engineid_len,
                        newKu, newKu_len, newkul, &newkul_len);
    QUITFUN(rval, main_quit);

    DEBUGMSGTL(("encode_keychange", "generating new Kul (%lu) (from Ku): ",
                (unsigned long)oldkul_len));
    for (i = 0; i < (int) newkul_len; i++)
        DEBUGMSGTL(("encode_keychange", "%02x", newkul[i]));
    DEBUGMSGTL(("encode_keychange", "\n"));

    rval = encode_keychange(transform_type, transform_type_len,
                            oldkul, oldkul_len,
                            newkul, newkul_len, keychange, &keychange_len);
    QUITFUN(rval, main_quit);



    binary_to_hex(keychange, keychange_len, &s);
    printf("%s%s\n", (verbose) ? "KeyChange string:\t" : "",    /* XXX stdout */
           s);


    /*
     * Cleanup.
     */
  main_quit:
    snmp_call_callbacks(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_SHUTDOWN,
                        NULL);


    SNMP_ZERO(oldpass, strlen(oldpass));
    SNMP_ZERO(newpass, strlen(newpass));

    memset(oldKu, 0, oldKu_len);
    memset(newKu, 0, newKu_len);

    memset(oldkul, 0, oldkul_len);
    memset(newkul, 0, newkul_len);

    SNMP_ZERO(s, strlen(s));

    return rval;

}                               /* end main() */




/*******************************************************************-o-******
 */
void
usage_synopsis(FILE * ofp)
{
    fprintf(ofp, USAGE "\n\
\n\
    -E [0x]<engineID>		EngineID used for kul generation.\n\
    -f				Force passphrases to be read from stdin.\n\
    -h				Help.\n\
    -N \"<new_passphrase>\"	Passphrase used to generate new Ku.\n\
    -O \"<old_passphrase>\"	Passphrase used to generate old Ku.\n\
    -P				Turn off prompt indicators.\n\
    -t md5 | sha1		HMAC hash transform type.\n\
    -v				Verbose.\n\
    -V				Visible.  Echo passphrases to terminal.\n\
		" NL, local_progname);

}                               /* end usage_synopsis() */

void
usage_to_file(FILE * ofp)
{
    char           *s;

    usage_synopsis(ofp);

    fprintf(ofp, "\n%s\
	a) Commandline options,\n\
	b) The file \"%s/%s\",\n\
	c) stdin  -or-  User input from the terminal.\n\n%s\
		" NL,
   "Only -t is mandatory.  The transform is used to convert P=>Ku, convert\n\
    Ku=>Kul, and to hash the old Kul with the random bits.\n\
\n\
    Passphrase will be taken from the first successful source as follows:\n",
    (s = getenv("HOME")) ? s : "$HOME", local_passphrase_filename,
   "-f will require reading from the stdin/terminal, ignoring a) and b).\n\
    -P will prevent prompts for passphrases to stdout from being printed.\n\
\n\
    <engineID> is interpreted as a hex string when preceded by \"0x\",\n\
    otherwise it is created to contain \"text\".  If nothing is given,\n\
    <engineID> is constructed from the first IP address for the local host.\n");


    /*
     * FIX -- make this possible?
     * -r [0x]<random_bits> Random bits used in KeyChange XOR.
     * 
     * <engineID> and <random_bits> are interpreted as hex strings when
     * preceeded by \"0x\", otherwise <engineID> is created to contain \"text\"
     * and <random_bits> are the same as the ascii input.
     * 
     * <random_bits> will be generated by SCAPI if not given.  If value is
     * too long, it will be truncated; if too short, the remainder will be
     * filled in with zeros.
     */

}                               /* end usage() */


/*
 * this defined for HPUX aCC because the aCC doesn't drop the 
 */
/*
 * snmp_parse_args.c functionality if compile with -g, PKY 
 */

void
usage(void)
{
    usage_to_file(stdout);
}





/*******************************************************************-o-******
 * get_user_passphrases
 *
 * Returns:
 *	SNMPERR_SUCCESS		Success.
 *	SNMPERR_GENERR		Otherwise.
 *
 *
 * Acquire new and old passphrases from the user:
 *
 *	+ Always prompt if 'forcepassphrase' is set.
 *	+ Use given arguments if they are defined.
 *	+ Otherwise read file format from PASSPHRASE_FILE.
 *		Sanity check existence and permissions of the path.
 *		ASSUME for now that PASSPHRASE_FILE is rooted only at $HOME.
 *	+ Otherwise prompt user for passphrase(s).
 *		Echo input if 'visible' is set.
 *		Turning off 'promptindicator' makes piping in input cleaner.
 *
 * NOTE Only using forcepassphrase mandates taking both passphrases
 * from the same source.  Otherwise processing continues until both 
 * passphrases are defined.
 */
int
get_user_passphrases(void)
{
    int             rval = SNMPERR_SUCCESS;
    size_t          len;

    char           *obuf = NULL, *nbuf = NULL;

    char            path[SNMP_MAXBUF], buf[SNMP_MAXBUF], *s = NULL;

    struct stat     statbuf;
    FILE           *fp = NULL;



    /*
     * Allow prompts to the user to override all other sources.
     * Nothing to do otherwise if oldpass and newpass are already defined.
     */
    if (forcepassphrase)
        goto get_user_passphrases_prompt;
    if (oldpass && newpass)
        goto get_user_passphrases_quit;



    /*
     * Read passphrases out of PASSPHRASE_FILE.  Sanity check the
     * path for existence and access first.  Refuse to read
     * if the permissions are wrong.
     */
    s = getenv("HOME");
    snprintf(path, sizeof(path), "%s/%s", s, PASSPHRASE_DIR);
    path[ sizeof(path)-1 ] = 0;

    /*
     * Test directory. 
     */
    if (stat(path, &statbuf) < 0) {
        fprintf(stderr, "Cannot access directory \"%s\".\n", path);
        QUITFUN(SNMPERR_GENERR, get_user_passphrases_quit);
#ifndef WIN32
    } else if (statbuf.st_mode & (S_IRWXG | S_IRWXO)) {
        fprintf(stderr,
                "Directory \"%s\" is accessible by group or world.\n",
                path);
        QUITFUN(SNMPERR_GENERR, get_user_passphrases_quit);
#endif                          /* !WIN32 */
    }

    /*
     * Test file. 
     */
    snprintf(path, sizeof(path), "%s/%s", s, local_passphrase_filename);
    path[ sizeof(path)-1 ] = 0;
    if (stat(path, &statbuf) < 0) {
        fprintf(stderr, "Cannot access file \"%s\".\n", path);
        QUITFUN(SNMPERR_GENERR, get_user_passphrases_quit);
#ifndef WIN32
    } else if (statbuf.st_mode & (S_IRWXG | S_IRWXO)) {
        fprintf(stderr,
                "File \"%s\" is accessible by group or world.\n", path);
        QUITFUN(SNMPERR_GENERR, get_user_passphrases_quit);
#endif                          /* !WIN32 */
    }

    /*
     * Open the file. 
     */
    if ((fp = fopen(path, "r")) == NULL) {
        fprintf(stderr, "Cannot open \"%s\".", path);
        QUITFUN(SNMPERR_GENERR, get_user_passphrases_quit);
    }

    /*
     * Read 1st line. 
     */
    if (!fgets(buf, sizeof(buf), fp)) {
        if (verbose) {
            fprintf(stderr, "Passphrase file \"%s\" is empty...\n", path);
        }
        goto get_user_passphrases_prompt;

    } else if (!oldpass) {
        len = strlen(buf);
        if (buf[len - 1] == '\n')
            buf[--len] = '\0';
        oldpass = (char *) calloc(1, len + 1);
        if (oldpass)
            memcpy(oldpass, buf, len + 1);
    }
    /*
     * Read 2nd line. 
     */
    if (!fgets(buf, sizeof(buf), fp)) {
        if (verbose) {
            fprintf(stderr, "Only one line in file \"%s\"...\n", path);
        }

    } else if (!newpass) {
        len = strlen(buf);
        if (buf[len - 1] == '\n')
            buf[--len] = '\0';
        newpass = (char *) calloc(1, len + 1);
        if (newpass)
            memcpy(newpass, buf, len + 1);
    }

    if (oldpass && newpass)
        goto get_user_passphrases_quit;



    /*
     * Prompt the user for passphrase entry.  Visible prompts
     * may be omitted, and invisible entry may turned off.
     */
  get_user_passphrases_prompt:
    if (forcepassphrase) {
        oldpass = newpass = NULL;
    }

    if (!oldpass) {
        oldpass = obuf
            = snmp_getpassphrase((promptindicator) ? "Old passphrase: " :
                                 "", visible);
    }
    if (!newpass) {
        newpass = nbuf
            = snmp_getpassphrase((promptindicator) ? "New passphrase: " :
                                 "", visible);
    }



    /*
     * Check that both passphrases were defined.
     */
    if (oldpass && newpass) {
        goto get_user_passphrases_quit;
    } else {
        rval = SNMPERR_GENERR;
    }


  get_user_passphrases_quit:
    memset(buf, 0, SNMP_MAXBUF);

    if (obuf != oldpass) {
        SNMP_ZERO(obuf, strlen(obuf));
        SNMP_FREE(obuf);
    }
    if (nbuf != newpass) {
        SNMP_ZERO(nbuf, strlen(nbuf));
        SNMP_FREE(nbuf);
    }

    if (fp)
        fclose (fp);
        
    return rval;

}                               /* end get_user_passphrases() */

/*******************************************************************-o-******
 * snmp_ttyecho
 *
 * Parameters:
 *	fd	Descriptor of terminal on which to toggle echoing.
 *	echo	TRUE if echoing should be on; FALSE otherwise.
 *      
 * Returns:
 *	Previous value of echo setting.
 *
 *
 * FIX	Put HAVE_TCGETATTR in autoconf?
 */
#ifndef HAVE_GETPASS
#ifdef HAVE_TCGETATTR
#include <termios.h>
int
snmp_ttyecho(const int fd, const int echo)
{
    struct termios  tio;
    int             was_echo;


    if (!isatty(fd))
        return (-1);
    tcgetattr(fd, &tio);
    was_echo = (tio.c_lflag & ECHO) != 0;
    if (echo)
        tio.c_lflag |= (ECHO | ECHONL);
    else
        tio.c_lflag &= ~(ECHO | ECHONL);
    tcsetattr(fd, TCSANOW, &tio);

    return (was_echo);

}                               /* end snmp_ttyecho() */

#else
#include <sgtty.h>
int
snmp_ttyecho(const int fd, const int echo)
{
    struct sgttyb   ttyparams;
    int             was_echo;


    if (!isatty(fd))
        was_echo = -1;
    else {
        ioctl(fd, TIOCGETP, &ttyparams);
        was_echo = (ttyparams.sg_flags & ECHO) != 0;
        if (echo)
            ttyparams.sg_flags = ttyparams.sg_flags | ECHO;
        else
            ttyparams.sg_flags = ttyparams.sg_flags & ~ECHO;
        ioctl(fd, TIOCSETP, &ttyparams);
    }

    return (was_echo);

}                               /* end snmp_ttyecho() */
#endif                          /* HAVE_TCGETATTR */
#endif                          /* HAVE_GETPASS */




/*******************************************************************-o-******
 * snmp_getpassphrase
 *
 * Parameters:
 *	*prompt		(May be NULL.)
 *	 bvisible	TRUE means echo back user input.
 *      
 * Returns:
 *	Pointer to newly allocated, null terminated string containing
 *		passphrase  -OR-
 *	NULL on error.
 *
 *
 * Prompt stdin for a string (or passphrase).  Return a copy of the 
 * input in a null terminated string.
 *
 * FIX	Put HAVE_GETPASS in autoconf.
 */
char           *
snmp_getpassphrase(const char *prompt, int bvisible)
{
    int             ti = 0;
    size_t          len;

    char           *bufp = NULL;
    static char     buffer[SNMP_MAXBUF];

    FILE           *ofp = stdout;


    /*
     * Query stdin for a passphrase.
     */
#ifdef HAVE_GETPASS
    if (isatty(0)) {
        return getpass((prompt) ? prompt : "");
    }
#endif

    fputs((prompt) ? prompt : "", ofp);

    if (!bvisible) {
        ti = snmp_ttyecho(0, 0);
    }

    bufp = fgets(buffer, sizeof(buffer), stdin);

    if (!bvisible) {
        ti = snmp_ttyecho(0, ti);
        fputs("\n", ofp);
    }
    if (!bufp) {
        fprintf(stderr, "Aborted...\n");
        exit(1);
    }


    /*
     * Copy the input and zero out the read-in buffer.
     */
    len = strlen(buffer);
    if (buffer[len - 1] == '\n')
        buffer[--len] = '\0';

    bufp = (char *) calloc(1, len + 1);
    if (bufp)
        memcpy(bufp, buffer, len + 1);

    memset(buffer, 0, SNMP_MAXBUF);


    return bufp;

}                               /* end snmp_getpassphrase() */

#if defined(HAVE__CPUTS) && defined(HAVE__GETCH)
int
snmp_ttyecho(const int fd, const int echo)
{
    return 0;
}

/*
 * stops at the first newline, carrier return, or backspace.
 * WARNING! _getch does NOT read <Ctrl-C>
 */
static char    *
getpass(const char *prompt)
{
    static char     pbuf[128];
    int             ch, lim;

    _cputs(prompt);
    for (ch = 0, lim = 0; ch != '\n' && lim < sizeof(pbuf)-1;) {
        ch = _getch();          /* look ma, no echo ! */
        if (ch == '\r' || ch == '\n' || ch == '\b')
            break;
        pbuf[lim++] = ch;
    }
    pbuf[lim] = '\0';
    puts("\n");

    return pbuf;
}
#endif /* defined(HAVE__CPUTS) && defined(HAVE__GETCH) */
