/*
* 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);
#ifdef WIN32
#define HAVE_GETPASS 1
char *getpass(const char *prompt);
int isatty(int);
int _cputs(const char *);
int _getch(void);
#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() */
#ifdef WIN32
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>
*/
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 /* WIN32 */