/** * Initialize library */ static void init() { plugin_feature_t features[] = { PLUGIN_NOOP, PLUGIN_PROVIDE(CUSTOM, "pt-tls-client"), PLUGIN_DEPENDS(CUSTOM, "tnccs-manager"), }; library_init(NULL, "pt-tls-client"); libtnccs_init(); init_log("pt-tls-client"); options = options_create(); lib->plugins->add_static_features(lib->plugins, "pt-tls-client", features, countof(features), TRUE, NULL, NULL); if (!lib->plugins->load(lib->plugins, lib->settings->get_str(lib->settings, "pt-tls-client.load", PLUGINS))) { exit(SS_RC_INITIALIZATION_FAILED); } lib->plugins->status(lib->plugins, LEVEL_CTRL); creds = mem_cred_create(); lib->credmgr->add_set(lib->credmgr, &creds->set); atexit(cleanup); }
/** * Initialize library */ static void init() { library_init(NULL, "tls_test"); dbg = dbg_tls; lib->plugins->load(lib->plugins, PLUGINS); creds = mem_cred_create(); lib->credmgr->add_set(lib->credmgr, &creds->set); atexit(cleanup); }
/** * @brief openac main program * * @param argc number of arguments * @param argv pointer to the argument values */ int main(int argc, char **argv) { certificate_t *attr_cert = NULL; certificate_t *userCert = NULL; certificate_t *signerCert = NULL; private_key_t *signerKey = NULL; time_t notBefore = UNDEFINED_TIME; time_t notAfter = UNDEFINED_TIME; time_t validity = 0; char *keyfile = NULL; char *certfile = NULL; char *usercertfile = NULL; char *outfile = NULL; char *groups = ""; char buf[BUF_LEN]; chunk_t passphrase = { buf, 0 }; chunk_t serial = chunk_empty; chunk_t attr_chunk = chunk_empty; int status = 1; /* enable openac debugging hook */ dbg = openac_dbg; passphrase.ptr[0] = '\0'; openlog("openac", 0, LOG_AUTHPRIV); /* initialize library */ atexit(library_deinit); if (!library_init(NULL)) { exit(SS_RC_LIBSTRONGSWAN_INTEGRITY); } if (lib->integrity && !lib->integrity->check_file(lib->integrity, "openac", argv[0])) { fprintf(stderr, "integrity check of openac failed\n"); exit(SS_RC_DAEMON_INTEGRITY); } if (!lib->plugins->load(lib->plugins, lib->settings->get_str(lib->settings, "openac.load", PLUGINS))) { exit(SS_RC_INITIALIZATION_FAILED); } /* initialize optionsfrom */ options_t *options = options_create(); /* handle arguments */ for (;;) { static const struct option long_opts[] = { /* name, has_arg, flag, val */ { "help", no_argument, NULL, 'h' }, { "version", no_argument, NULL, 'v' }, { "optionsfrom", required_argument, NULL, '+' }, { "quiet", no_argument, NULL, 'q' }, { "cert", required_argument, NULL, 'c' }, { "key", required_argument, NULL, 'k' }, { "password", required_argument, NULL, 'p' }, { "usercert", required_argument, NULL, 'u' }, { "groups", required_argument, NULL, 'g' }, { "days", required_argument, NULL, 'D' }, { "hours", required_argument, NULL, 'H' }, { "startdate", required_argument, NULL, 'S' }, { "enddate", required_argument, NULL, 'E' }, { "out", required_argument, NULL, 'o' }, { "debug", required_argument, NULL, 'd' }, { 0,0,0,0 } }; int c = getopt_long(argc, argv, "hv+:qc:k:p;u:g:D:H:S:E:o:d:", long_opts, NULL); /* Note: "breaking" from case terminates loop */ switch (c) { case EOF: /* end of flags */ break; case 0: /* long option already handled */ continue; case ':': /* diagnostic already printed by getopt_long */ case '?': /* diagnostic already printed by getopt_long */ case 'h': /* --help */ usage(NULL); status = 1; goto end; case 'v': /* --version */ printf("openac (strongSwan %s)\n", VERSION); status = 0; goto end; case '+': /* --optionsfrom <filename> */ { char path[BUF_LEN]; if (*optarg == '/') /* absolute pathname */ { strncpy(path, optarg, BUF_LEN); path[BUF_LEN-1] = '\0'; } else /* relative pathname */ { snprintf(path, BUF_LEN, "%s/%s", OPENAC_PATH, optarg); } if (!options->from(options, path, &argc, &argv, optind)) { status = 1; goto end; } } continue; case 'q': /* --quiet */ stderr_quiet = TRUE; continue; case 'c': /* --cert */ certfile = optarg; continue; case 'k': /* --key */ keyfile = optarg; continue; case 'p': /* --key */ if (strlen(optarg) >= BUF_LEN) { usage("passphrase too long"); goto end; } strncpy(passphrase.ptr, optarg, BUF_LEN); passphrase.len = min(strlen(optarg), BUF_LEN); continue; case 'u': /* --usercert */ usercertfile = optarg; continue; case 'g': /* --groups */ groups = optarg; continue; case 'D': /* --days */ if (optarg == NULL || !isdigit(optarg[0])) { usage("missing number of days"); goto end; } else { char *endptr; long days = strtol(optarg, &endptr, 0); if (*endptr != '\0' || endptr == optarg || days <= 0) { usage("<days> must be a positive number"); goto end; } validity += 24*3600*days; } continue; case 'H': /* --hours */ if (optarg == NULL || !isdigit(optarg[0])) { usage("missing number of hours"); goto end; } else { char *endptr; long hours = strtol(optarg, &endptr, 0); if (*endptr != '\0' || endptr == optarg || hours <= 0) { usage("<hours> must be a positive number"); goto end; } validity += 3600*hours; } continue; case 'S': /* --startdate */ if (optarg == NULL || strlen(optarg) != 15 || optarg[14] != 'Z') { usage("date format must be YYYYMMDDHHMMSSZ"); goto end; } else { chunk_t date = { optarg, 15 }; notBefore = asn1_to_time(&date, ASN1_GENERALIZEDTIME); } continue; case 'E': /* --enddate */ if (optarg == NULL || strlen(optarg) != 15 || optarg[14] != 'Z') { usage("date format must be YYYYMMDDHHMMSSZ"); goto end; } else { chunk_t date = { optarg, 15 }; notAfter = asn1_to_time(&date, ASN1_GENERALIZEDTIME); } continue; case 'o': /* --out */ outfile = optarg; continue; case 'd': /* --debug */ debug_level = atoi(optarg); continue; default: usage(""); status = 0; goto end; } /* break from loop */ break; } if (optind != argc) { usage("unexpected argument"); goto end; } DBG1(DBG_LIB, "starting openac (strongSwan Version %s)", VERSION); /* load the signer's RSA private key */ if (keyfile != NULL) { mem_cred_t *mem; shared_key_t *shared; mem = mem_cred_create(); lib->credmgr->add_set(lib->credmgr, &mem->set); shared = shared_key_create(SHARED_PRIVATE_KEY_PASS, chunk_clone(passphrase)); mem->add_shared(mem, shared, NULL); signerKey = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_RSA, BUILD_FROM_FILE, keyfile, BUILD_END); lib->credmgr->remove_set(lib->credmgr, &mem->set); mem->destroy(mem); if (signerKey == NULL) { goto end; } DBG1(DBG_LIB, " loaded private key file '%s'", keyfile); } /* load the signer's X.509 certificate */ if (certfile != NULL) { signerCert = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509, BUILD_FROM_FILE, certfile, BUILD_END); if (signerCert == NULL) { goto end; } } /* load the users's X.509 certificate */ if (usercertfile != NULL) { userCert = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509, BUILD_FROM_FILE, usercertfile, BUILD_END); if (userCert == NULL) { goto end; } } /* compute validity interval */ validity = (validity)? validity : DEFAULT_VALIDITY; notBefore = (notBefore == UNDEFINED_TIME) ? time(NULL) : notBefore; notAfter = (notAfter == UNDEFINED_TIME) ? time(NULL) + validity : notAfter; /* build and parse attribute certificate */ if (userCert != NULL && signerCert != NULL && signerKey != NULL && outfile != NULL) { /* read the serial number and increment it by one */ serial = read_serial(); attr_cert = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509_AC, BUILD_CERT, userCert, BUILD_NOT_BEFORE_TIME, notBefore, BUILD_NOT_AFTER_TIME, notAfter, BUILD_SERIAL, serial, BUILD_IETF_GROUP_ATTR, groups, BUILD_SIGNING_CERT, signerCert, BUILD_SIGNING_KEY, signerKey, BUILD_END); if (!attr_cert) { goto end; } /* write the attribute certificate to file */ if (attr_cert->get_encoding(attr_cert, CERT_ASN1_DER, &attr_chunk)) { if (chunk_write(attr_chunk, outfile, 0022, TRUE)) { DBG1(DBG_APP, " written attribute cert file '%s' (%d bytes)", outfile, attr_chunk.len); write_serial(serial); status = 0; } else { DBG1(DBG_APP, " writing attribute cert file '%s' failed: %s", outfile, strerror(errno)); } } } else { usage("some of the mandatory parameters --usercert --cert --key --out " "are missing"); } end: /* delete all dynamically allocated objects */ DESTROY_IF(signerKey); DESTROY_IF(signerCert); DESTROY_IF(userCert); DESTROY_IF(attr_cert); free(attr_chunk.ptr); free(serial.ptr); closelog(); dbg = dbg_default; options->destroy(options); exit(status); }
/** * Wrap/Unwrap PKCs#7 containers */ static int pkcs7() { char *arg, *file = NULL; private_key_t *key = NULL; certificate_t *cert = NULL; chunk_t data = chunk_empty; mem_cred_t *creds; int res = 1; FILE *in; enum { OP_NONE, OP_SIGN, OP_VERIFY, OP_ENCRYPT, OP_DECRYPT, OP_SHOW, } op = OP_NONE; creds = mem_cred_create(); while (TRUE) { switch (command_getopt(&arg)) { case 'h': creds->destroy(creds); return command_usage(NULL); case 'i': file = arg; continue; case 's': if (op != OP_NONE) { goto invalid; } op = OP_SIGN; continue; case 'u': if (op != OP_NONE) { goto invalid; } op = OP_VERIFY; continue; case 'e': if (op != OP_NONE) { goto invalid; } op = OP_ENCRYPT; continue; case 'd': if (op != OP_NONE) { goto invalid; } op = OP_DECRYPT; continue; case 'p': if (op != OP_NONE) { goto invalid; } op = OP_SHOW; continue; case 'k': key = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_RSA, BUILD_FROM_FILE, arg, BUILD_END); if (!key) { fprintf(stderr, "parsing private key failed\n"); goto end; } creds->add_key(creds, key); continue; case 'c': cert = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509, BUILD_FROM_FILE, arg, BUILD_END); if (!cert) { fprintf(stderr, "parsing certificate failed\n"); goto end; } creds->add_cert(creds, TRUE, cert); continue; case EOF: break; default: invalid: creds->destroy(creds); return command_usage("invalid --pkcs7 option"); } break; } if (file) { in = fopen(file, "r"); if (in) { data = read_from_stream(in); fclose(in); } } else { data = read_from_stream(stdin); } if (!data.len) { fprintf(stderr, "reading input failed!\n"); goto end; } if (op != OP_SHOW && !cert) { fprintf(stderr, "requiring a certificate!\n"); goto end; } lib->credmgr->add_local_set(lib->credmgr, &creds->set, FALSE); switch (op) { case OP_SIGN: if (!key) { fprintf(stderr, "signing requires a private key\n"); res = 1; break; } res = sign(data, cert, key); break; case OP_VERIFY: res = verify(data); break; case OP_ENCRYPT: res = encrypt(data, cert); break; case OP_DECRYPT: if (!key) { fprintf(stderr, "decryption requires a private key\n"); res = 1; break; } res = decrypt(data); break; case OP_SHOW: res = show(data); break; default: res = 1; break; } lib->credmgr->remove_local_set(lib->credmgr, &creds->set); end: creds->destroy(creds); free(data.ptr); return res; }
/** * Verify a certificate signature */ static int verify() { bool trusted = FALSE, valid = FALSE, revoked = FALSE; bool has_ca = FALSE, online = FALSE; certificate_t *cert; enumerator_t *enumerator; auth_cfg_t *auth; mem_cred_t *creds; char *arg, *file = NULL; creds = mem_cred_create(); lib->credmgr->add_set(lib->credmgr, &creds->set); while (TRUE) { switch (command_getopt(&arg)) { case 'h': creds->destroy(creds); return command_usage(NULL); case 'i': file = arg; continue; case 'c': if (load_certs(creds, arg, CERT_X509)) { has_ca = TRUE; } continue; case 'l': if (load_certs(creds, arg, CERT_X509_CRL)) { online = TRUE; } continue; case 'o': online = TRUE; continue; case EOF: break; default: creds->destroy(creds); return command_usage("invalid --verify option"); } break; } if (file) { cert = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509, BUILD_FROM_FILE, file, BUILD_END); } else { chunk_t chunk; set_file_mode(stdin, CERT_ASN1_DER); if (!chunk_from_fd(0, &chunk)) { fprintf(stderr, "reading certificate failed: %s\n", strerror(errno)); goto end; } cert = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509, BUILD_BLOB, chunk, BUILD_END); free(chunk.ptr); } if (!cert) { fprintf(stderr, "parsing certificate failed\n"); goto end; } cert = creds->add_cert_ref(creds, !has_ca, cert); enumerator = lib->credmgr->create_trusted_enumerator(lib->credmgr, KEY_ANY, cert->get_subject(cert), online); if (enumerator->enumerate(enumerator, &cert, &auth)) { trusted = TRUE; if (cert->get_validity(cert, NULL, NULL, NULL)) { printf("certificate trusted, lifetimes valid"); valid = TRUE; } else { printf("certificate trusted, but no valid lifetime"); } if (online) { switch ((uintptr_t)auth->get(auth, AUTH_RULE_CRL_VALIDATION)) { case VALIDATION_GOOD: printf(", certificate not revoked"); break; case VALIDATION_SKIPPED: printf(", no revocation information"); break; case VALIDATION_STALE: printf(", revocation information stale"); break; case VALIDATION_FAILED: printf(", revocation checking failed"); break; case VALIDATION_ON_HOLD: printf(", certificate revocation on hold"); revoked = TRUE; break; case VALIDATION_REVOKED: printf(", certificate revoked"); revoked = TRUE; break; } } printf("\n"); } enumerator->destroy(enumerator); cert->destroy(cert); if (!trusted) { printf("certificate untrusted\n"); } end: lib->credmgr->remove_set(lib->credmgr, &creds->set); creds->destroy(creds); if (!trusted) { return 1; } if (!valid) { return 2; } if (revoked) { return 3; } return 0; }
/** * @brief main of scepclient * * @param argc number of arguments * @param argv pointer to the argument values */ int main(int argc, char **argv) { /* external values */ extern char * optarg; extern int optind; /* type of input and output files */ typedef enum { PKCS1 = 0x01, PKCS10 = 0x02, PKCS7 = 0x04, CERT_SELF = 0x08, CERT = 0x10, CACERT_ENC = 0x20, CACERT_SIG = 0x40, } scep_filetype_t; /* filetype to read from, defaults to "generate a key" */ scep_filetype_t filetype_in = 0; /* filetype to write to, no default here */ scep_filetype_t filetype_out = 0; /* input files */ char *file_in_pkcs1 = DEFAULT_FILENAME_PKCS1; char *file_in_pkcs10 = DEFAULT_FILENAME_PKCS10; char *file_in_cert_self = DEFAULT_FILENAME_CERT_SELF; char *file_in_cacert_enc = DEFAULT_FILENAME_CACERT_ENC; char *file_in_cacert_sig = DEFAULT_FILENAME_CACERT_SIG; /* output files */ char *file_out_pkcs1 = DEFAULT_FILENAME_PKCS1; char *file_out_pkcs10 = DEFAULT_FILENAME_PKCS10; char *file_out_pkcs7 = DEFAULT_FILENAME_PKCS7; char *file_out_cert_self = DEFAULT_FILENAME_CERT_SELF; char *file_out_cert = DEFAULT_FILENAME_CERT; char *file_out_ca_cert = DEFAULT_FILENAME_CACERT_ENC; /* by default user certificate is requested */ bool request_ca_certificate = FALSE; /* by default existing files are not overwritten */ bool force = FALSE; /* length of RSA key in bits */ u_int rsa_keylength = DEFAULT_RSA_KEY_LENGTH; /* validity of self-signed certificate */ time_t validity = DEFAULT_CERT_VALIDITY; time_t notBefore = 0; time_t notAfter = 0; /* distinguished name for requested certificate, ASCII format */ char *distinguishedName = NULL; /* challenge password */ char challenge_password_buffer[MAX_PASSWORD_LENGTH]; /* symmetric encryption algorithm used by pkcs7, default is DES */ encryption_algorithm_t pkcs7_symmetric_cipher = ENCR_DES; size_t pkcs7_key_size = 0; /* digest algorithm used by pkcs7, default is MD5 */ hash_algorithm_t pkcs7_digest_alg = HASH_MD5; /* signature algorithm used by pkcs10, default is MD5 */ hash_algorithm_t pkcs10_signature_alg = HASH_MD5; /* URL of the SCEP-Server */ char *scep_url = NULL; /* Name of CA to fetch CA certs for */ char *ca_name = "CAIdentifier"; /* http request method, default is GET */ bool http_get_request = TRUE; /* poll interval time in manual mode in seconds */ u_int poll_interval = DEFAULT_POLL_INTERVAL; /* maximum poll time */ u_int max_poll_time = 0; err_t ugh = NULL; /* initialize library */ if (!library_init(NULL)) { library_deinit(); exit(SS_RC_LIBSTRONGSWAN_INTEGRITY); } if (lib->integrity && !lib->integrity->check_file(lib->integrity, "scepclient", argv[0])) { fprintf(stderr, "integrity check of scepclient failed\n"); library_deinit(); exit(SS_RC_DAEMON_INTEGRITY); } /* initialize global variables */ pkcs1 = chunk_empty; pkcs7 = chunk_empty; serialNumber = chunk_empty; transID = chunk_empty; fingerprint = chunk_empty; encoding = chunk_empty; pkcs10_encoding = chunk_empty; issuerAndSubject = chunk_empty; challengePassword = chunk_empty; getCertInitial = chunk_empty; scep_response = chunk_empty; subjectAltNames = linked_list_create(); options = options_create(); for (;;) { static const struct option long_opts[] = { /* name, has_arg, flag, val */ { "help", no_argument, NULL, 'h' }, { "version", no_argument, NULL, 'v' }, { "optionsfrom", required_argument, NULL, '+' }, { "quiet", no_argument, NULL, 'q' }, { "debug", required_argument, NULL, 'l' }, { "in", required_argument, NULL, 'i' }, { "out", required_argument, NULL, 'o' }, { "force", no_argument, NULL, 'f' }, { "httptimeout", required_argument, NULL, 'T' }, { "keylength", required_argument, NULL, 'k' }, { "dn", required_argument, NULL, 'd' }, { "days", required_argument, NULL, 'D' }, { "startdate", required_argument, NULL, 'S' }, { "enddate", required_argument, NULL, 'E' }, { "subjectAltName", required_argument, NULL, 's' }, { "password", required_argument, NULL, 'p' }, { "algorithm", required_argument, NULL, 'a' }, { "url", required_argument, NULL, 'u' }, { "caname", required_argument, NULL, 'c'}, { "method", required_argument, NULL, 'm' }, { "interval", required_argument, NULL, 't' }, { "maxpolltime", required_argument, NULL, 'x' }, { 0,0,0,0 } }; /* parse next option */ int c = getopt_long(argc, argv, "hv+:qi:o:fk:d:s:p:a:u:c:m:t:x:APRCMS", long_opts, NULL); switch (c) { case EOF: /* end of flags */ break; case 'h': /* --help */ usage(NULL); case 'v': /* --version */ version(); case 'q': /* --quiet */ log_to_stderr = FALSE; continue; case 'l': /* --debug <level> */ default_loglevel = atoi(optarg); continue; case 'i': /* --in <type> [= <filename>] */ { char *filename = strstr(optarg, "="); if (filename) { /* replace '=' by '\0' */ *filename = '\0'; /* set pointer to start of filename */ filename++; } if (strcaseeq("pkcs1", optarg)) { filetype_in |= PKCS1; if (filename) file_in_pkcs1 = filename; } else if (strcaseeq("pkcs10", optarg)) { filetype_in |= PKCS10; if (filename) file_in_pkcs10 = filename; } else if (strcaseeq("cacert-enc", optarg)) { filetype_in |= CACERT_ENC; if (filename) file_in_cacert_enc = filename; } else if (strcaseeq("cacert-sig", optarg)) { filetype_in |= CACERT_SIG; if (filename) file_in_cacert_sig = filename; } else if (strcaseeq("cert-self", optarg)) { filetype_in |= CERT_SELF; if (filename) file_in_cert_self = filename; } else { usage("invalid --in file type"); } continue; } case 'o': /* --out <type> [= <filename>] */ { char *filename = strstr(optarg, "="); if (filename) { /* replace '=' by '\0' */ *filename = '\0'; /* set pointer to start of filename */ filename++; } if (strcaseeq("pkcs1", optarg)) { filetype_out |= PKCS1; if (filename) file_out_pkcs1 = filename; } else if (strcaseeq("pkcs10", optarg)) { filetype_out |= PKCS10; if (filename) file_out_pkcs10 = filename; } else if (strcaseeq("pkcs7", optarg)) { filetype_out |= PKCS7; if (filename) file_out_pkcs7 = filename; } else if (strcaseeq("cert-self", optarg)) { filetype_out |= CERT_SELF; if (filename) file_out_cert_self = filename; } else if (strcaseeq("cert", optarg)) { filetype_out |= CERT; if (filename) file_out_cert = filename; } else if (strcaseeq("cacert", optarg)) { request_ca_certificate = TRUE; if (filename) file_out_ca_cert = filename; } else { usage("invalid --out file type"); } continue; } case 'f': /* --force */ force = TRUE; continue; case 'T': /* --httptimeout */ http_timeout = atoi(optarg); if (http_timeout <= 0) { usage("invalid httptimeout specified"); } continue; case '+': /* --optionsfrom <filename> */ if (!options->from(options, optarg, &argc, &argv, optind)) { exit_scepclient("optionsfrom failed"); } continue; case 'k': /* --keylength <length> */ { div_t q; rsa_keylength = atoi(optarg); if (rsa_keylength == 0) usage("invalid keylength"); /* check if key length is a multiple of 8 bits */ q = div(rsa_keylength, 2*BITS_PER_BYTE); if (q.rem != 0) { exit_scepclient("keylength is not a multiple of %d bits!" , 2*BITS_PER_BYTE); } continue; } case 'D': /* --days */ if (optarg == NULL || !isdigit(optarg[0])) { usage("missing number of days"); } else { char *endptr; long days = strtol(optarg, &endptr, 0); if (*endptr != '\0' || endptr == optarg || days <= 0) usage("<days> must be a positive number"); validity = 24*3600*days; } continue; case 'S': /* --startdate */ if (optarg == NULL || strlen(optarg) != 13 || optarg[12] != 'Z') { usage("date format must be YYMMDDHHMMSSZ"); } else { chunk_t date = { optarg, 13 }; notBefore = asn1_to_time(&date, ASN1_UTCTIME); } continue; case 'E': /* --enddate */ if (optarg == NULL || strlen(optarg) != 13 || optarg[12] != 'Z') { usage("date format must be YYMMDDHHMMSSZ"); } else { chunk_t date = { optarg, 13 }; notAfter = asn1_to_time(&date, ASN1_UTCTIME); } continue; case 'd': /* --dn */ if (distinguishedName) { usage("only one distinguished name allowed"); } distinguishedName = optarg; continue; case 's': /* --subjectAltName */ { char *value = strstr(optarg, "="); if (value) { /* replace '=' by '\0' */ *value = '\0'; /* set pointer to start of value */ value++; } if (strcaseeq("email", optarg) || strcaseeq("dns", optarg) || strcaseeq("ip", optarg)) { subjectAltNames->insert_last(subjectAltNames, identification_create_from_string(value)); continue; } else { usage("invalid --subjectAltName type"); continue; } } case 'p': /* --password */ if (challengePassword.len > 0) { usage("only one challenge password allowed"); } if (strcaseeq("%prompt", optarg)) { printf("Challenge password: "******"challenge password could not be read"); } } else { challengePassword.ptr = optarg; challengePassword.len = strlen(optarg); } continue; case 'u': /* -- url */ if (scep_url) { usage("only one URL argument allowed"); } scep_url = optarg; continue; case 'c': /* -- caname */ ca_name = optarg; continue; case 'm': /* --method */ if (strcaseeq("get", optarg)) { http_get_request = TRUE; } else if (strcaseeq("post", optarg)) { http_get_request = FALSE; } else { usage("invalid http request method specified"); } continue; case 't': /* --interval */ poll_interval = atoi(optarg); if (poll_interval <= 0) { usage("invalid interval specified"); } continue; case 'x': /* --maxpolltime */ max_poll_time = atoi(optarg); continue; case 'a': /*--algorithm [<type>=]algo */ { const proposal_token_t *token; char *type = optarg; char *algo = strstr(optarg, "="); if (algo) { *algo = '\0'; algo++; } else { type = "enc"; algo = optarg; } if (strcaseeq("enc", type)) { token = lib->proposal->get_token(lib->proposal, algo); if (token == NULL || token->type != ENCRYPTION_ALGORITHM) { usage("invalid algorithm specified"); } pkcs7_symmetric_cipher = token->algorithm; pkcs7_key_size = token->keysize; if (encryption_algorithm_to_oid(token->algorithm, token->keysize) == OID_UNKNOWN) { usage("unsupported encryption algorithm specified"); } } else if (strcaseeq("dgst", type) || strcaseeq("sig", type)) { hash_algorithm_t hash; token = lib->proposal->get_token(lib->proposal, algo); if (token == NULL || token->type != INTEGRITY_ALGORITHM) { usage("invalid algorithm specified"); } hash = hasher_algorithm_from_integrity(token->algorithm, NULL); if (hash == OID_UNKNOWN) { usage("invalid algorithm specified"); } if (strcaseeq("dgst", type)) { pkcs7_digest_alg = hash; } else { pkcs10_signature_alg = hash; } } else { usage("invalid --algorithm type"); } continue; } default: usage("unknown option"); } /* break from loop */ break; } init_log("scepclient"); /* load plugins, further infrastructure may need it */ if (!lib->plugins->load(lib->plugins, NULL, lib->settings->get_str(lib->settings, "scepclient.load", PLUGINS))) { exit_scepclient("plugin loading failed"); } DBG1(DBG_APP, " loaded plugins: %s", lib->plugins->loaded_plugins(lib->plugins)); if ((filetype_out == 0) && (!request_ca_certificate)) { usage("--out filetype required"); } if (request_ca_certificate && (filetype_out > 0 || filetype_in > 0)) { usage("in CA certificate request, no other --in or --out option allowed"); } /* check if url is given, if cert output defined */ if (((filetype_out & CERT) || request_ca_certificate) && !scep_url) { usage("URL of SCEP server required"); } /* check for sanity of --in/--out */ if (!filetype_in && (filetype_in > filetype_out)) { usage("cannot generate --out of given --in!"); } /* get CA cert */ if (request_ca_certificate) { char ca_path[PATH_MAX]; container_t *container; pkcs7_t *pkcs7; if (!scep_http_request(scep_url, chunk_create(ca_name, strlen(ca_name)), SCEP_GET_CA_CERT, http_get_request, http_timeout, &scep_response)) { exit_scepclient("did not receive a valid scep response"); } join_paths(ca_path, sizeof(ca_path), CA_CERT_PATH, file_out_ca_cert); pkcs7 = lib->creds->create(lib->creds, CRED_CONTAINER, CONTAINER_PKCS7, BUILD_BLOB_ASN1_DER, scep_response, BUILD_END); if (!pkcs7) { /* no PKCS#7 encoded CA+RA certificates, assume simple CA cert */ DBG1(DBG_APP, "unable to parse PKCS#7, assuming plain CA cert"); if (!chunk_write(scep_response, ca_path, "ca cert", 0022, force)) { exit_scepclient("could not write ca cert file '%s'", ca_path); } } else { enumerator_t *enumerator; certificate_t *cert; int ra_certs = 0, ca_certs = 0; int ra_index = 1, ca_index = 1; enumerator = pkcs7->create_cert_enumerator(pkcs7); while (enumerator->enumerate(enumerator, &cert)) { x509_t *x509 = (x509_t*)cert; if (x509->get_flags(x509) & X509_CA) { ca_certs++; } else { ra_certs++; } } enumerator->destroy(enumerator); enumerator = pkcs7->create_cert_enumerator(pkcs7); while (enumerator->enumerate(enumerator, &cert)) { x509_t *x509 = (x509_t*)cert; bool ca_cert = x509->get_flags(x509) & X509_CA; char cert_path[PATH_MAX], *path = ca_path; if (ca_cert && ca_certs > 1) { add_path_suffix(cert_path, sizeof(cert_path), ca_path, "-%.1d", ca_index++); path = cert_path; } else if (!ca_cert) { /* use CA name as base for RA certs */ if (ra_certs > 1) { add_path_suffix(cert_path, sizeof(cert_path), ca_path, "-ra-%.1d", ra_index++); } else { add_path_suffix(cert_path, sizeof(cert_path), ca_path, "-ra"); } path = cert_path; } if (!cert->get_encoding(cert, CERT_ASN1_DER, &encoding) || !chunk_write(encoding, path, ca_cert ? "ca cert" : "ra cert", 0022, force)) { exit_scepclient("could not write cert file '%s'", path); } chunk_free(&encoding); } enumerator->destroy(enumerator); container = &pkcs7->container; container->destroy(container); } exit_scepclient(NULL); /* no further output required */ } creds = mem_cred_create(); lib->credmgr->add_set(lib->credmgr, &creds->set); /* * input of PKCS#1 file */ if (filetype_in & PKCS1) /* load an RSA key pair from file */ { char path[PATH_MAX]; join_paths(path, sizeof(path), PRIVATE_KEY_PATH, file_in_pkcs1); private_key = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_RSA, BUILD_FROM_FILE, path, BUILD_END); } else /* generate an RSA key pair */ { private_key = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_RSA, BUILD_KEY_SIZE, rsa_keylength, BUILD_END); } if (private_key == NULL) { exit_scepclient("no RSA private key available"); } creds->add_key(creds, private_key->get_ref(private_key)); public_key = private_key->get_public_key(private_key); /* check for minimum key length */ if (private_key->get_keysize(private_key) < RSA_MIN_OCTETS / BITS_PER_BYTE) { exit_scepclient("length of RSA key has to be at least %d bits", RSA_MIN_OCTETS * BITS_PER_BYTE); } /* * input of PKCS#10 file */ if (filetype_in & PKCS10) { char path[PATH_MAX]; join_paths(path, sizeof(path), REQ_PATH, file_in_pkcs10); pkcs10_req = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_PKCS10_REQUEST, BUILD_FROM_FILE, path, BUILD_END); if (!pkcs10_req) { exit_scepclient("could not read certificate request '%s'", path); } subject = pkcs10_req->get_subject(pkcs10_req); subject = subject->clone(subject); } else { if (distinguishedName == NULL) { char buf[BUF_LEN]; int n = sprintf(buf, DEFAULT_DN); /* set the common name to the hostname */ if (gethostname(buf + n, BUF_LEN - n) || strlen(buf) == n) { exit_scepclient("no hostname defined, use " "--dn <distinguished name> option"); } distinguishedName = buf; } DBG2(DBG_APP, "dn: '%s'", distinguishedName); subject = identification_create_from_string(distinguishedName); if (subject->get_type(subject) != ID_DER_ASN1_DN) { exit_scepclient("parsing of distinguished name failed"); } DBG2(DBG_APP, "building pkcs10 object:"); pkcs10_req = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_PKCS10_REQUEST, BUILD_SIGNING_KEY, private_key, BUILD_SUBJECT, subject, BUILD_SUBJECT_ALTNAMES, subjectAltNames, BUILD_CHALLENGE_PWD, challengePassword, BUILD_DIGEST_ALG, pkcs10_signature_alg, BUILD_END); if (!pkcs10_req) { exit_scepclient("generating pkcs10 request failed"); } } pkcs10_req->get_encoding(pkcs10_req, CERT_ASN1_DER, &pkcs10_encoding); fingerprint = scep_generate_pkcs10_fingerprint(pkcs10_encoding); DBG1(DBG_APP, " fingerprint: %s", fingerprint.ptr); /* * output of PKCS#10 file */ if (filetype_out & PKCS10) { char path[PATH_MAX]; join_paths(path, sizeof(path), REQ_PATH, file_out_pkcs10); if (!chunk_write(pkcs10_encoding, path, "pkcs10", 0022, force)) { exit_scepclient("could not write pkcs10 file '%s'", path); } filetype_out &= ~PKCS10; /* delete PKCS10 flag */ } if (!filetype_out) { exit_scepclient(NULL); /* no further output required */ } /* * output of PKCS#1 file */ if (filetype_out & PKCS1) { char path[PATH_MAX]; join_paths(path, sizeof(path), PRIVATE_KEY_PATH, file_out_pkcs1); DBG2(DBG_APP, "building pkcs1 object:"); if (!private_key->get_encoding(private_key, PRIVKEY_ASN1_DER, &pkcs1) || !chunk_write(pkcs1, path, "pkcs1", 0066, force)) { exit_scepclient("could not write pkcs1 file '%s'", path); } filetype_out &= ~PKCS1; /* delete PKCS1 flag */ } if (!filetype_out) { exit_scepclient(NULL); /* no further output required */ } scep_generate_transaction_id(public_key, &transID, &serialNumber); DBG1(DBG_APP, " transaction ID: %.*s", (int)transID.len, transID.ptr); /* * read or generate self-signed X.509 certificate */ if (filetype_in & CERT_SELF) { char path[PATH_MAX]; join_paths(path, sizeof(path), HOST_CERT_PATH, file_in_cert_self); x509_signer = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509, BUILD_FROM_FILE, path, BUILD_END); if (!x509_signer) { exit_scepclient("could not read certificate file '%s'", path); } } else { notBefore = notBefore ? notBefore : time(NULL); notAfter = notAfter ? notAfter : (notBefore + validity); x509_signer = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509, BUILD_SIGNING_KEY, private_key, BUILD_PUBLIC_KEY, public_key, BUILD_SUBJECT, subject, BUILD_NOT_BEFORE_TIME, notBefore, BUILD_NOT_AFTER_TIME, notAfter, BUILD_SERIAL, serialNumber, BUILD_SUBJECT_ALTNAMES, subjectAltNames, BUILD_END); if (!x509_signer) { exit_scepclient("generating certificate failed"); } } creds->add_cert(creds, TRUE, x509_signer->get_ref(x509_signer)); /* * output of self-signed X.509 certificate file */ if (filetype_out & CERT_SELF) { char path[PATH_MAX]; join_paths(path, sizeof(path), HOST_CERT_PATH, file_out_cert_self); if (!x509_signer->get_encoding(x509_signer, CERT_ASN1_DER, &encoding)) { exit_scepclient("encoding certificate failed"); } if (!chunk_write(encoding, path, "self-signed cert", 0022, force)) { exit_scepclient("could not write self-signed cert file '%s'", path); } chunk_free(&encoding); filetype_out &= ~CERT_SELF; /* delete CERT_SELF flag */ } if (!filetype_out) { exit_scepclient(NULL); /* no further output required */ } /* * load ca encryption certificate */ { char path[PATH_MAX]; join_paths(path, sizeof(path), CA_CERT_PATH, file_in_cacert_enc); x509_ca_enc = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509, BUILD_FROM_FILE, path, BUILD_END); if (!x509_ca_enc) { exit_scepclient("could not load encryption cacert file '%s'", path); } } /* * input of PKCS#7 file */ if (filetype_in & PKCS7) { /* user wants to load a pkcs7 encrypted request * operation is not yet supported! * would require additional parsing of transaction-id pkcs7 = pkcs7_read_from_file(file_in_pkcs7); */ } else { DBG2(DBG_APP, "building pkcs7 request"); pkcs7 = scep_build_request(pkcs10_encoding, transID, SCEP_PKCSReq_MSG, x509_ca_enc, pkcs7_symmetric_cipher, pkcs7_key_size, x509_signer, pkcs7_digest_alg, private_key); if (!pkcs7.ptr) { exit_scepclient("failed to build pkcs7 request"); } } /* * output pkcs7 encrypted and signed certificate request */ if (filetype_out & PKCS7) { char path[PATH_MAX]; join_paths(path, sizeof(path), REQ_PATH, file_out_pkcs7); if (!chunk_write(pkcs7, path, "pkcs7 encrypted request", 0022, force)) { exit_scepclient("could not write pkcs7 file '%s'", path); } filetype_out &= ~PKCS7; /* delete PKCS7 flag */ } if (!filetype_out) { exit_scepclient(NULL); /* no further output required */ } /* * output certificate fetch from SCEP server */ if (filetype_out & CERT) { bool stored = FALSE; certificate_t *cert; enumerator_t *enumerator; char path[PATH_MAX]; time_t poll_start = 0; pkcs7_t *p7; container_t *container = NULL; chunk_t chunk; scep_attributes_t attrs = empty_scep_attributes; join_paths(path, sizeof(path), CA_CERT_PATH, file_in_cacert_sig); x509_ca_sig = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509, BUILD_FROM_FILE, path, BUILD_END); if (!x509_ca_sig) { exit_scepclient("could not load signature cacert file '%s'", path); } creds->add_cert(creds, TRUE, x509_ca_sig->get_ref(x509_ca_sig)); if (!scep_http_request(scep_url, pkcs7, SCEP_PKI_OPERATION, http_get_request, http_timeout, &scep_response)) { exit_scepclient("did not receive a valid scep response"); } ugh = scep_parse_response(scep_response, transID, &container, &attrs); if (ugh != NULL) { exit_scepclient(ugh); } /* in case of manual mode, we are going into a polling loop */ if (attrs.pkiStatus == SCEP_PENDING) { identification_t *issuer = x509_ca_sig->get_subject(x509_ca_sig); DBG1(DBG_APP, " scep request pending, polling every %d seconds", poll_interval); poll_start = time_monotonic(NULL); issuerAndSubject = asn1_wrap(ASN1_SEQUENCE, "cc", issuer->get_encoding(issuer), subject); } while (attrs.pkiStatus == SCEP_PENDING) { if (max_poll_time > 0 && (time_monotonic(NULL) - poll_start >= max_poll_time)) { exit_scepclient("maximum poll time reached: %d seconds" , max_poll_time); } DBG2(DBG_APP, "going to sleep for %d seconds", poll_interval); sleep(poll_interval); free(scep_response.ptr); container->destroy(container); DBG2(DBG_APP, "fingerprint: %.*s", (int)fingerprint.len, fingerprint.ptr); DBG2(DBG_APP, "transaction ID: %.*s", (int)transID.len, transID.ptr); chunk_free(&getCertInitial); getCertInitial = scep_build_request(issuerAndSubject, transID, SCEP_GetCertInitial_MSG, x509_ca_enc, pkcs7_symmetric_cipher, pkcs7_key_size, x509_signer, pkcs7_digest_alg, private_key); if (!getCertInitial.ptr) { exit_scepclient("failed to build scep request"); } if (!scep_http_request(scep_url, getCertInitial, SCEP_PKI_OPERATION, http_get_request, http_timeout, &scep_response)) { exit_scepclient("did not receive a valid scep response"); } ugh = scep_parse_response(scep_response, transID, &container, &attrs); if (ugh != NULL) { exit_scepclient(ugh); } } if (attrs.pkiStatus != SCEP_SUCCESS) { container->destroy(container); exit_scepclient("reply status is not 'SUCCESS'"); } if (!container->get_data(container, &chunk)) { container->destroy(container); exit_scepclient("extracting signed-data failed"); } container->destroy(container); /* decrypt enveloped-data container */ container = lib->creds->create(lib->creds, CRED_CONTAINER, CONTAINER_PKCS7, BUILD_BLOB_ASN1_DER, chunk, BUILD_END); free(chunk.ptr); if (!container) { exit_scepclient("could not decrypt envelopedData"); } if (!container->get_data(container, &chunk)) { container->destroy(container); exit_scepclient("extracting encrypted-data failed"); } container->destroy(container); /* parse signed-data container */ container = lib->creds->create(lib->creds, CRED_CONTAINER, CONTAINER_PKCS7, BUILD_BLOB_ASN1_DER, chunk, BUILD_END); free(chunk.ptr); if (!container) { exit_scepclient("could not parse singed-data"); } /* no need to verify the signed-data container, the signature does NOT * cover the contained certificates */ /* store the end entity certificate */ join_paths(path, sizeof(path), HOST_CERT_PATH, file_out_cert); p7 = (pkcs7_t*)container; enumerator = p7->create_cert_enumerator(p7); while (enumerator->enumerate(enumerator, &cert)) { x509_t *x509 = (x509_t*)cert; if (!(x509->get_flags(x509) & X509_CA)) { if (stored) { exit_scepclient("multiple certs received, only first stored"); } if (!cert->get_encoding(cert, CERT_ASN1_DER, &encoding) || !chunk_write(encoding, path, "requested cert", 0022, force)) { exit_scepclient("could not write cert file '%s'", path); } chunk_free(&encoding); stored = TRUE; } } enumerator->destroy(enumerator); container->destroy(container); chunk_free(&attrs.transID); chunk_free(&attrs.senderNonce); chunk_free(&attrs.recipientNonce); filetype_out &= ~CERT; /* delete CERT flag */ } exit_scepclient(NULL); return -1; /* should never be reached */ }