/* Simple argumetn parsing. */
static void parse_arguments(int argc, char **argv)
{
char opt;
while ((opt = ssh_getopt(argc, argv, "t:i:d:h", NULL)) != EOF)
{
switch (opt)
{
case 't':
provider_type = ssh_optarg;
break;
case 'i':
initialization_string = ssh_optarg;
break;
case 'd':
debug_level_string = ssh_optarg;
break;
case 'h':
case '?':
default:
/* the Usage. */
print_usage();
exit(1);
}
}
}
int getopt(int argc, char **argv, char *ostr)
{
int r;
ssh_get_externals();
r = ssh_getopt(argc, argv, ostr, ((SshGetOptData)0));
ssh_set_externals();
return r;
}
int main(int argc, char **argv)
{
int opt;
ssh_regression_init(&argc, &argv, "Combined modes",
"*****@*****.**");
while ((opt = ssh_getopt(argc, argv, "d:", NULL)) != EOF)
{
switch (opt)
{
case 'd':
debuglevel = ssh_optarg;
break;
default:
fprintf(stderr, "usage: t-combined-modes [-d debuglevel] \n");
exit(1);
}
}
if (ssh_crypto_library_initialize() != SSH_CRYPTO_OK)
ssh_fatal("Crypto library initialization failed");
if (debuglevel)
ssh_debug_set_level_string(debuglevel);
test_variant("");
test_variant("-256");
test_variant("-4k");
test_variant("-8k");
test_variant("-64k");
ssh_crypto_library_uninitialize();
ssh_debug_uninit();
ssh_regression_finish();
exit(0);
}
int main(int argc, char* argv[])
{
t_tcpc_context pcontext = 0;
SshGetOptData pgetoptdata = 0;
int i;
SSH_TRACE(SSH_D_MY, ("%s", "main"));
pcontext = ssh_xmalloc(sizeof (*pcontext));
memset(pcontext, 0, sizeof (*pcontext));
pgetoptdata = ssh_xmalloc(sizeof (*pgetoptdata));
memset(pgetoptdata, 0, sizeof (*pgetoptdata));
ssh_getopt_init_data(pgetoptdata);
pcontext->pport_or_service = "23242";
while ((i = ssh_getopt(argc, argv, "p:h:d:D:G:t:", pgetoptdata)) != -1)
{
switch (i)
{
case 'p':
pcontext->pport_or_service = ssh_xstrdup(pgetoptdata->arg);
break;
case 'h':
pcontext->phost_name_or_address = ssh_xstrdup(pgetoptdata->arg);
break;
case 'd':
pcontext->pdata = ssh_xstrdup(pgetoptdata->arg);
break;
case 'D':
ssh_debug_set_module_level(SSH_DEBUG_MODULE, atoi(pgetoptdata->arg));
break;
case 'G':
ssh_debug_set_global_level(atoi(pgetoptdata->arg));
break;
case 't':
pcontext->timeout = atoi(pgetoptdata->arg);
break;
default:
SSH_NOTREACHED;
break;
}
}
ssh_xfree(pgetoptdata);
ssh_event_loop_initialize();
pcontext->pbuffer = ssh_buffer_allocate();
if (pcontext->phost_name_or_address)
{
ssh_tcp_connect(pcontext->phost_name_or_address,
pcontext->pport_or_service,
NULL,
t_tcpc_tcp_callback,
pcontext);
}
else
{
pcontext->ptcplistener =
ssh_tcp_make_listener(SSH_IPADDR_ANY_IPV4,
pcontext->pport_or_service,
NULL,
t_tcpc_tcp_callback,
pcontext);
}
ssh_event_loop_run();
ssh_name_server_uninit();
ssh_event_loop_uninitialize();
ssh_buffer_free(pcontext->pbuffer);
ssh_xfree(pcontext);
ssh_util_uninit();
return 0;
}
int
main(int argc, char *argv[])
{
int c;
const char *debug_string = "SshHttpFilterProxy=5";
SshHttpServerParams params;
SshHttpServerContext ctx;
memset(¶ms, 0, sizeof(params));
params.port = "8080";
#ifndef WIN32
signal(SIGPIPE, SIG_IGN);
#endif /* not WIN32 */
/* Remove the directory part from the program name. */
program = strrchr(argv[0], '/');
if (program == NULL)
program = argv[0];
else
program++;
/* Parse options. */
while ((c = ssh_getopt(argc, argv, "d:hp:P:", NULL)) != EOF)
{
switch (c)
{
case 'd':
debug_string = ssh_optarg;
break;
case 'h':
usage();
exit(0);
break;
case 'p':
params.port = ssh_optarg;
break;
case 'P':
proxy_url = ssh_optarg;
break;
}
}
if (ssh_optind < argc)
{
fprintf(stderr, "%s: garbage after options.\n\n", program);
usage();
exit(1);
}
ssh_debug_set_level_string(debug_string);
ssh_event_loop_initialize();
read_censor_list();
SSH_DEBUG(SSH_D_HIGHSTART, ("running on %s", params.port));
ctx = ssh_http_server_start(¶ms);
if (ctx)
{
/* Set the URI handlers. */
ssh_http_server_set_handler(ctx, "http://*", 0, proxy_handler, NULL);
ssh_http_server_set_handler(ctx, "/catch*", 0, catch_handler, NULL);
ssh_http_server_set_handler(ctx, "*", 10, authentication_handler, NULL);
ssh_event_loop_run();
}
else
fprintf(stderr, "%s: couldn't create listener\n", program);
ssh_event_loop_uninitialize();
return 0;
}
int main(int argc, char **argv)
{
int c;
SshCryptoStatus cs;
SshCipher cipher;
Boolean all_ciphers = FALSE, speed_test = FALSE, quiet = FALSE;
unsigned char *iv = NULL, *key = NULL;
size_t iv_len = 0, key_len = 0;
char *cipher_name = NULL, *cipher_names, *hlp, *passphrase = NULL;
Boolean encrypt_mode = TRUE;
char *input_file = NULL, *output_file = NULL;
FILE *fin, *fout;
Boolean r = TRUE;
if (strchr(argv[0], '/'))
av0 = strrchr(argv[0], '/') + 1;
else
av0 = argv[0];
if (strcasecmp(av0, "ssh-encrypt") == 0)
encrypt_mode = TRUE;
else if (strcasecmp(av0, "ssh-decrypt") == 0)
encrypt_mode = FALSE;
if (ssh_crypto_library_initialize() != SSH_CRYPTO_OK)
{
fprintf(stderr, "Can't initialize the cryptographic provider.\n");
exit(1);
}
while ((c = ssh_getopt(argc, argv, "thd:ac:i:k:EDp:", NULL)) != -1)
{
switch (c)
{
case 'd':
ssh_debug_set_level_string(ssh_optarg);
break;
case 't':
speed_test = TRUE;
break;
case 'a':
all_ciphers = TRUE;
break;
case 'c':
cipher_name = ssh_xstrdup(ssh_optarg);
break;
case 'q':
quiet = TRUE;
break;
case 'i':
if (iv)
{
fprintf(stderr,
"%s: No multiple initialization vectors allowed.\n",
av0);
usage();
exit(-1);
}
if (! hex_string_to_data(ssh_optarg, &iv, &iv_len))
{
fprintf(stderr, "%s: Bad IV string.\n", av0);
exit(-1);
}
break;
case 'k':
if (key)
{
fprintf(stderr, "%s: No multiple keys allowed.\n", av0);
usage();
exit(-1);
}
if (! hex_string_to_data(ssh_optarg, &key, &key_len))
{
fprintf(stderr, "%s: Bad KEY string.\n", av0);
exit(-1);
}
break;
case 'p':
if (passphrase)
{
fprintf(stderr, "%s: No multiple passphrases allowed.\n", av0);
usage();
exit(-1);
}
passphrase = ssh_optarg;
break;
case 'E':
encrypt_mode = TRUE;
break;
case 'D':
encrypt_mode = FALSE;
break;
case 'h':
help_info();
usage();
exit(0);
/*NOTREACHED*/
default:
usage();
exit(-1);
/*NOTREACHED*/
}
}
argc -= ssh_optind;
argv += ssh_optind;
if (speed_test && (argc > 0))
{
fprintf(stderr, "%s: Extra parameters.\n", av0);
usage();
exit(-1);
/*NOTREACHED*/
}
if (argc > 2)
{
fprintf(stderr, "%s: Extra parameters.\n", av0);
usage();
exit(-1);
/*NOTREACHED*/
}
if (argc > 1)
output_file = ssh_xstrdup(argv[1]);
if (argc > 0)
input_file = ssh_xstrdup(argv[0]);
if ((cipher_name != NULL) && all_ciphers)
{
fprintf(stderr, "%s: -c and -a can't be used together.\n", av0);
usage();
exit(-1);
/*NOTREACHED*/
}
if (all_ciphers && !speed_test)
{
fprintf(stderr, "%s: -a can only be used with -t.\n", av0);
usage();
exit(-1);
/*NOTREACHED*/
}
if ((cipher_name != NULL) && strchr(cipher_name, ',') && !speed_test)
{
fprintf(stderr, "%s: Multiple ciphers only be used with -t.\n", av0);
usage();
exit(-1);
/*NOTREACHED*/
}
if (cipher_name == NULL)
{
if (speed_test)
{
all_ciphers = TRUE; /* Assume `all' if test mode with no ciphers. */
}
else
{
fprintf(stderr, "Missing -c flag.\n");
usage();
exit(-1);
/*NOTREACHED*/
}
}
if (passphrase && key)
{
fprintf(stderr, "%s: Can't use both passphrase and hex key.\n", av0);
usage();
exit(-1);
/*NOTREACHED*/
}
if (!key && !passphrase && !speed_test)
{
ssh_warning("%s: No key! Empty passphrase assumed.", av0);
passphrase = "";
/*NOTREACHED*/
}
if (speed_test)
{
fprintf(stderr, "Performing speed tests\n");
if (all_ciphers)
{
cipher_names = ssh_cipher_get_supported();
}
else
{
/* Steal allocated cipher_name */
cipher_names = cipher_name;
cipher_name = NULL;
}
hlp = cipher_names;
while ((cipher_name = ssh_name_list_get_name(hlp)) != NULL)
{
hlp += strlen(cipher_name);
if (*hlp == ',')
hlp++;
cipher_speed_test(cipher_name,
passphrase,
key, key_len,
iv, iv_len,
encrypt_mode);
ssh_xfree(cipher_name);
if (strlen(hlp) == 0)
break;
}
ssh_xfree(cipher_names);
}
else
{
if (passphrase)
cs = ssh_cipher_allocate_with_passphrase(cipher_name,
passphrase,
encrypt_mode,
&cipher);
else
cs = ssh_cipher_allocate(cipher_name,
key,
key_len,
encrypt_mode,
&cipher);
if (cs != SSH_CRYPTO_OK)
{
switch (cs)
{
case SSH_CRYPTO_UNSUPPORTED:
fprintf(stderr, "%s: Unsupported cipher \"%s\".\n", av0,
cipher_name);
usage();
exit(-1);
case SSH_CRYPTO_KEY_TOO_SHORT:
fprintf(stderr, "%s: Key too short for \"%s\".\n", av0,
cipher_name);
usage();
exit(-1);
default:
fprintf(stderr, "%s: Cipher allocate failed.\n", av0);
exit(-1);
}
/*NOTREACHED*/
}
if (iv != NULL)
{
if (ssh_cipher_get_iv_length(ssh_cipher_name(cipher)) == iv_len)
ssh_cipher_set_iv(cipher, iv);
else
{
fprintf(stderr, "%s: Weird IV length.\n", av0);
exit(-1);
}
}
if (input_file != NULL)
{
fin = fopen(input_file, "r");
if (fin == NULL)
{
fprintf(stderr, "%s: Cannot open input file \"%s\".\n",
av0, input_file);
exit(-1);
}
}
else
{
fin = stdin;
}
if (output_file != NULL)
{
struct stat st;
if (stat(output_file, &st) >= 0)
{
fprintf(stderr, "%s: Output file \"%s\" exists.\n", av0,
output_file);
exit(-1);
}
fout = fopen(output_file, "w");
if (fout == NULL)
{
fprintf(stderr, "%s: Cannot open output file \"%s\".\n",
av0, output_file);
exit(-1);
}
}
else
{
fout = stdout;
}
if (encrypt_mode)
r = cipher_encrypt(cipher, fin, fout);
else
r = cipher_decrypt(cipher, fin, fout);
if (input_file)
fclose(fin);
if (output_file)
{
fclose(fout);
if (! r)
(void)unlink(output_file);
}
ssh_cipher_free(cipher);
ssh_xfree(cipher_name);
}
ssh_xfree(input_file);
ssh_xfree(output_file);
ssh_xfree(key);
ssh_xfree(iv);
ssh_crypto_library_uninitialize();
ssh_util_uninit();
return((r == TRUE) ? 0 : -1);
}
int main(int ac, char **av)
{
int opt, i;
DIR *ssh2dir = NULL;
char *ssh2dirname;
Boolean dynamic_array = FALSE;
struct dirent * cand;
/* Save program name. */
if (strchr(av[0], '/'))
av0 = strrchr(av[0], '/') + 1;
else
av0 = av[0];
user = ssh_user_initialize(NULL, FALSE);
#ifdef WITH_PGP
pgp_keyring = ssh_xstrdup(SSH_PGP_SECRET_KEY_FILE);
#endif /* WITH_PGP */
action = ADD;
while ((opt = ssh_getopt(ac, av, "ldDput:f:F:1LUNPI", NULL)) != EOF)
{
if (!ssh_optval)
{
usage();
exit(EXIT_STATUS_ERROR);
}
switch (opt)
{
case 'N':
#ifdef WITH_PGP
pgp_mode = PGP_KEY_NAME;
#else /* WITH_PGP */
fprintf(stderr, "%s: PGP keys not supported.\n", av0);
exit(EXIT_STATUS_ERROR);
#endif /* WITH_PGP */
break;
case 'P':
#ifdef WITH_PGP
pgp_mode = PGP_KEY_FINGERPRINT;
#else /* WITH_PGP */
fprintf(stderr, "%s: PGP keys not supported.\n", av0);
exit(EXIT_STATUS_ERROR);
#endif /* WITH_PGP */
break;
case 'I':
#ifdef WITH_PGP
pgp_mode = PGP_KEY_ID;
#else /* WITH_PGP */
fprintf(stderr, "%s: PGP keys not supported.\n", av0);
exit(EXIT_STATUS_ERROR);
#endif /* WITH_PGP */
break;
case 'R':
#ifdef WITH_PGP
ssh_xfree(pgp_keyring);
pgp_keyring = ssh_xstrdup(ssh_optarg);
#else /* WITH_PGP */
fprintf(stderr, "%s: PGP keys not supported.\n", av0);
exit(EXIT_STATUS_ERROR);
#endif /* WITH_PGP */
break;
case 'l':
action = LIST;
break;
case 'p':
use_stdin = TRUE;
break;
case 'd':
if (action == ADD_URL)
action = DELETE_URL;
else
action = DELETE;
break;
case 'D':
action = DELETE_ALL;
break;
case 't':
if (ssh_optargnum)
{
key_timeout = (SshTime)(ssh_optargval * 60);
}
else
{
usage();
exit(EXIT_STATUS_ERROR);
}
have_attrs = TRUE;
break;
case 'f':
if (ssh_optargnum)
{
path_limit = (SshUInt32)ssh_optargval;
}
else
{
usage();
exit(EXIT_STATUS_ERROR);
}
have_attrs = TRUE;
break;
case 'F':
path_constraint = ssh_xstrdup(ssh_optarg);
have_attrs = TRUE;
break;
case '1':
forbid_compat = TRUE;
have_attrs = TRUE;
break;
case 'u':
if (action == DELETE)
action = DELETE_URL;
else
action = ADD_URL;
break;
case 'L':
action = LOCK;
break;
case 'U':
action = UNLOCK;
break;
default:
usage();
exit(EXIT_STATUS_ERROR);
}
}
#ifdef WITH_PGP
if (pgp_keyring[0] != '/')
{
char buf[1024];
snprintf(buf, sizeof (buf), "%s/%s/%s",
ssh_user_dir(user),
SSH_USER_DIR,
pgp_keyring);
ssh_xfree(pgp_keyring);
pgp_keyring = ssh_xstrdup(buf);
}
#endif /* WITH_PGP */
files = &av[ssh_optind];
num_files = ac - ssh_optind;
/* Fetch default from ~/.ssh2/id_* (the first that we happen to get) */
#define ID_PREFIX "id"
if (num_files == 0 && action != LIST && action != DELETE_ALL &&
action != LOCK && action != UNLOCK)
{
#ifdef WITH_PGP
if (pgp_mode != PGP_KEY_NONE)
{
fprintf(stderr, "%s: Nothing to do!\n", av0);
exit(EXIT_STATUS_ERROR);
}
#endif /* WITH_PGP */
ssh_dsprintf(&ssh2dirname, "%s/%s", ssh_user_dir(user), SSH_USER_DIR);
ssh2dir = opendir(ssh2dirname);
if (!ssh2dir)
{
fprintf(stderr, "%s: Can't open directory \"%s\"", av0, ssh2dirname);
exit(EXIT_STATUS_ERROR);
}
while ((cand = readdir(ssh2dir)) != NULL)
{
if ((strlen(cand->d_name) > strlen(ID_PREFIX)) &&
(strncmp(cand->d_name, ID_PREFIX, strlen(ID_PREFIX)) == 0) &&
((strlen(cand->d_name) < 4) ||
(strcmp(cand->d_name + strlen(cand->d_name) - 4,
".pub") != 0)) &&
((((cand->d_name)[strlen(ID_PREFIX)]) == '_') ||
(((cand->d_name)[strlen(ID_PREFIX)]) == '-') ||
(((cand->d_name)[strlen(ID_PREFIX)]) == '.') ||
(((cand->d_name)[strlen(ID_PREFIX)]) == '(') ||
(((cand->d_name)[strlen(ID_PREFIX)]) == '[') ||
(((cand->d_name)[strlen(ID_PREFIX)]) == '<') ||
(((cand->d_name)[strlen(ID_PREFIX)]) == '>')))
{
files = ssh_xcalloc(2, sizeof(char *));
ssh_dsprintf(&files[0], "%s/%s", ssh2dirname, cand->d_name);
ssh_xfree(ssh2dirname);
num_files++;
dynamic_array = TRUE;
break;
}
}
(void)closedir(ssh2dir);
}
signal(SIGPIPE, SIG_IGN);
ssh_event_loop_initialize();
ssh_agent_open(agent_open_callback, NULL);
ssh_event_loop_run();
ssh_event_loop_uninitialize();
if (dynamic_array)
{
for(i = 0; i < num_files ; i++)
{
ssh_xfree(files[i]);
}
ssh_xfree(files);
}
ssh_user_free(user, FALSE);
exit(EXIT_STATUS_OK);
}
void parse_arguments(int argc, char **argv)
{
char opt;
while ((opt = ssh_getopt(argc, argv, "d:ht:n:api:cs", NULL)) != EOF)
{
switch (opt)
{
case 'c':
continuous_test = TRUE;
break;
case 'n':
default_accelerated_encrypts = atoi(ssh_optarg);
break;
case 'a':
accelerator_test = FALSE;
break;
case 'p':
test_only_private_key = TRUE;
break;
case 's':
test_signatures_only = TRUE;
break;
case 't':
timeout_ms = atoi(ssh_optarg);
break;
case 'd':
debug_level_string = ssh_optarg;
break;
case 'i':
accelerator_init_str = ssh_optarg;
break;
case 'h':
case '?':
default:
/* the Usage. */
printf("Test for Externalkey. Parameters: \n"
"-a Turn accelerator test OFF.\n"
"\tEncrypts and decrypts are done using normal "
"software keys\n"
"-n number of time to test the accelerator\n"
"-t set the timeout (in ms) between the encrypts\n"
"-i set the initialization string of the accelerator\n"
"-s run a signature and signature verification test\n"
"\t(default is 'collect_random(500, 10)')\n"
"-p Run a private key test only\n"
"-c Run continous test. Send USR1 to get statistics\n"
"-d set the debug level string");
printf("\nDefaults are:\n");
printf("Accelerator test: TRUE\n"
"Number of encrypts/decrypt to do: %ld\n"
"Timeout (ms) between encrypts: %ld\n",
default_accelerated_encrypts,
timeout_ms);
exit(1);
}
}
}
