/**
* Returns a list of all x509 certificates in a PKCS12 object.
*/
static STACK_OF(X509) *pkcs12_listCerts(PKCS12 *p12) {
STACK_OF(X509) *x509s = sk_X509_new_null();
if (!x509s) return NULL;
// Extract all PKCS7 safes
STACK_OF(PKCS7) *pkcs7s = PKCS12_unpack_authsafes(p12);
if (!pkcs7s) {
certutil_updateErrorString();
sk_X509_free(x509s);
return NULL;
}
// For each PKCS7 safe
int nump = sk_PKCS7_num(pkcs7s);
for (int p = 0; p < nump; p++) {
PKCS7 *p7 = sk_PKCS7_value(pkcs7s, p);
if (!p7) continue;
STACK_OF(PKCS12_SAFEBAG) *safebags = PKCS12_unpack_p7data(p7);
if (!safebags) {
certutil_updateErrorString();
continue;
}
// For each PKCS12 safebag
int numb = sk_PKCS12_SAFEBAG_num(safebags);
for (int i = 0; i < numb; i++) {
PKCS12_SAFEBAG *bag = sk_PKCS12_SAFEBAG_value(safebags, i);
if (!bag) continue;
if (M_PKCS12_bag_type(bag) == NID_certBag) {
// Extract x509 cert
X509 *x509 = PKCS12_certbag2x509(bag);
if (x509 == NULL) {
certutil_updateErrorString();
} else {
sk_X509_push(x509s, x509);
}
}
}
sk_PKCS12_SAFEBAG_pop_free(safebags, PKCS12_SAFEBAG_free);
}
sk_PKCS7_pop_free(pkcs7s, PKCS7_free);
return x509s;
}
static TokenError _backend_sign(PKCS12Token *token,
const char *message, size_t messagelen,
char **signature, size_t *siglen) {
if (!message || !signature || !siglen) {
assert(false);
return TokenError_Unknown;
}
if (messagelen >= UINT_MAX) return TokenError_MessageTooLong;
// Find the certificate for the token
STACK_OF(X509) *certList = pkcs12_listCerts(token->sharedP12->data);
if (!certList) return TokenError_Unknown;
X509 *cert = certutil_findCert(certList, token->subjectName,
token->base.backend->notifier->keyUsage,
false);
if (!cert) {
sk_X509_pop_free(certList, X509_free);
return TokenError_Unknown;
}
// Get the corresponding private key
EVP_PKEY *key = getPrivateKey(token->sharedP12->data, cert,
token->base.password);
sk_X509_pop_free(certList, X509_free);
if (!key) return TokenError_BadPassword;
// Sign with the default crypto with SHA1
unsigned int sig_len = EVP_PKEY_size(key);
*siglen = sig_len;
*signature = malloc(sig_len);
EVP_MD_CTX sig_ctx;
EVP_MD_CTX_init(&sig_ctx);
bool success = (EVP_SignInit(&sig_ctx, EVP_sha1()) &&
EVP_SignUpdate(&sig_ctx, message, messagelen) &&
EVP_SignFinal(&sig_ctx, (unsigned char*)*signature,
&sig_len, key));
EVP_MD_CTX_cleanup(&sig_ctx);
EVP_PKEY_free(key);
*siglen = sig_len;
if (success) {
return TokenError_Success;
} else {
certutil_updateErrorString();
free(*signature);
return TokenError_SignatureFailure;
}
}
static EVP_PKEY *getPrivateKey(PKCS12 *p12, X509 *x509, const char* pass) {
// Extract all PKCS7 safes
STACK_OF(PKCS7) *pkcs7s = PKCS12_unpack_authsafes(p12);
if (!pkcs7s) {
certutil_updateErrorString();
return NULL;
}
// For each PKCS7 safe
int nump = sk_PKCS7_num(pkcs7s);
for (int p = 0; p < nump; p++) {
PKCS7 *p7 = sk_PKCS7_value(pkcs7s, p);
if (!p7) continue;
STACK_OF(PKCS12_SAFEBAG) *safebags = PKCS12_unpack_p7data(p7);
if (!safebags) continue;
// For each PKCS12 safebag
int numb = sk_PKCS12_SAFEBAG_num(safebags);
for (int i = 0; i < numb; i++) {
PKCS12_SAFEBAG *bag = sk_PKCS12_SAFEBAG_value(safebags, i);
if (!bag) continue;
switch (M_PKCS12_bag_type(bag)) {
case NID_pkcs8ShroudedKeyBag:;
// Encrypted key
PKCS8_PRIV_KEY_INFO *p8 = PKCS12_decrypt_skey(bag, pass, strlen(pass));
if (p8) {
EVP_PKEY *pk = EVP_PKCS82PKEY(p8);
PKCS8_PRIV_KEY_INFO_free(p8);
if (!pk) break; // out of switch
if (X509_check_private_key(x509, pk) > 0) {
sk_PKCS12_SAFEBAG_pop_free(safebags, PKCS12_SAFEBAG_free);
sk_PKCS7_pop_free(pkcs7s, PKCS7_free);
return pk;
}
EVP_PKEY_free(pk);
}
break;
}
}
sk_PKCS12_SAFEBAG_pop_free(safebags, PKCS12_SAFEBAG_free);
}
sk_PKCS7_pop_free(pkcs7s, PKCS7_free);
return NULL;
}
TokenError _backend_createRequest(const RegutilInfo *info,
const char *hostname,
const char *password,
char **request, size_t *reqlen) {
// OpenSSL seeds the PRNG automatically, see the manual page for RAND_add.
if (!RAND_status()) {
fprintf(stderr, BINNAME ": no random state!\n");
return TokenError_NoRandomState;
}
// Abort if there are no requests
*request = NULL;
if (!info->pkcs10) return TokenError_Unknown;
// Create certificate requests
bool ok = true;
CertReq *reqs = NULL;
STACK *x509reqs = sk_new_null();
for (const RegutilPKCS10 *pkcs10 = info->pkcs10; pkcs10 != NULL;
pkcs10 = pkcs10->next) {
RSA *rsa = NULL;
EVP_PKEY *privkey = NULL;
X509_NAME *subject = NULL;
X509_REQ *x509req = NULL;
STACK_OF(X509_EXTENSION) *exts = NULL;
// Check the parameters.
// Maximum key size in OpenSSL:
// http://www.mail-archive.com/[email protected]/msg58229.html
if (!pkcs10->subjectDN || pkcs10->keySize < 1024 ||
pkcs10->keySize > 16384)
goto req_error;
// Generate key pair
// FIXME deprecated function
// TODO use OPENSSL_NO_DEPRECATED
rsa = RSA_generate_key(pkcs10->keySize, RSA_F4, NULL, NULL);
if (!rsa) goto req_error;
privkey = EVP_PKEY_new();
if (!privkey) goto req_error;
EVP_PKEY_assign_RSA(privkey, rsa);
// Subject name
subject = certutil_parse_dn(pkcs10->subjectDN, pkcs10->includeFullDN);
if (!subject) goto req_error;
// Create request
x509req = X509_REQ_new();
if (!x509req ||
!X509_REQ_set_version(x509req, 0) ||
!X509_REQ_set_subject_name(x509req, subject) ||
!X509_REQ_set_pubkey(x509req, privkey)) { // yes this is correct(!)
certutil_updateErrorString();
goto req_error;
}
// Set attributes
exts = sk_X509_EXTENSION_new_null();
if (!exts) goto req_error;
X509_EXTENSION *ext = makeKeyUsageExt(pkcs10->keyUsage);
if (!ext || !sk_X509_EXTENSION_push(exts, ext))
goto req_error;
if (!X509_REQ_add_extensions(x509req, exts)) {
certutil_updateErrorString();
goto req_error;
}
exts = NULL;
// Add signature
if (!X509_REQ_sign(x509req, privkey, EVP_sha1())) {
certutil_updateErrorString();
goto req_error;
}
// Store in list
CertReq *req = malloc(sizeof(CertReq));
req->pkcs10 = pkcs10;
req->privkey = privkey;
req->rsa = rsa;
req->x509 = x509req;
req->next = reqs;
reqs = req;
sk_push(x509reqs, (char*)x509req);
continue;
req_error:
// Clean up and set error flag
if (privkey) EVP_PKEY_free(privkey);
else if (rsa) RSA_free(rsa);
X509_NAME_free(subject);
sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
X509_REQ_free(x509req);
ok = false;
}
TokenError error = TokenError_Unknown;
if (ok) {
// Determine filename from certificate name
char *filename = certutil_makeFilename(X509_REQ_get_subject_name(reqs->x509));
// Build the certificate request
request_wrap(x509reqs, request, reqlen);
if (*request && filename) {
// Create the key file in ~/cbt/name.p12
FILE *keyfile = platform_openLocked(filename, Platform_OpenCreate);
if (!keyfile) {
error = TokenError_CantCreateFile;
} else {
error = saveKeys(reqs, hostname, password, keyfile);
if (!platform_closeLocked(keyfile) && !error)
error = TokenError_CantCreateFile;
}
}
if (filename) free(filename);
if (error && *request) free(*request);
}
// Free reqs
while (reqs) {
RSA_free(reqs->rsa); // This free's privkey too
X509_REQ_free(reqs->x509);
CertReq *next = reqs->next;
free(reqs);
reqs = next;
}
sk_free(x509reqs);
return error;
}
static TokenError saveKeys(const CertReq *reqs, const char *hostname,
const char *password, FILE *file) {
TokenError error = TokenError_Unknown;
PKCS12 *p12 = NULL;
// Add PKCS7 safes with the keys
STACK_OF(PKCS7) *authsafes = NULL;
uint32_t localKeyId = 0;
size_t error_count = 0;
while (reqs) {
STACK_OF(PKCS12_SAFEBAG) *bags = NULL;
X509 *cert = NULL;
ASN1_OBJECT *objOwningHost = NULL;
uint32_t keyid = htonl(localKeyId++);
bool success = false;
// Add private key
PKCS12_SAFEBAG *bag = PKCS12_add_key(&bags, reqs->privkey,
opensslKeyUsages[reqs->pkcs10->keyUsage], ENC_ITER, ENC_NID, (char*)password);
if (!bag) goto loop_end;
// Add name and localKeyId to the key bag
// TODO extract name from subject DN
char *name = "names are not implemented yet";
if (!X509at_add1_attr_by_NID(&bag->attrib, NID_friendlyName, MBSTRING_UTF8,
(unsigned char*)name, strlen(name)) ||
!PKCS12_add_localkeyid(bag, (unsigned char*)&keyid, sizeof(keyid)))
goto loop_end;
// Add a certificate so we can find the key by the subject name
cert = X509_REQ_to_X509(reqs->x509, 3650, reqs->privkey);
if (!cert ||
!X509_keyid_set1(cert, (unsigned char*)&keyid, sizeof(keyid)))
goto loop_end;
if (!X509_add_ext(cert, makeKeyUsageExt(reqs->pkcs10->keyUsage), -1))
goto loop_end;
if (!PKCS12_add_cert(&bags, cert))
goto loop_end;
// Add hostname (FriBID extension) so we can do same-origin checks
// TODO maybe we should use document.domain instead of document.location.hostname?
objOwningHost = OBJ_txt2obj(OID_OWNING_HOST, 1);
if (!objOwningHost) goto loop_end;
bag = sk_PKCS12_SAFEBAG_value(bags, sk_PKCS12_SAFEBAG_num(bags)-1);
if (!X509at_add1_attr_by_OBJ(&bag->attrib, objOwningHost, MBSTRING_UTF8,
(unsigned char*)hostname, strlen(hostname)))
goto loop_end;
// Add a new authsafe
if (!PKCS12_add_safe(&authsafes, bags, -1, 0, NULL))
goto loop_end;
// Success!
success = true;
loop_end:
if (!success) {
error_count--;
certutil_updateErrorString();
}
ASN1_OBJECT_free(objOwningHost);
X509_free(cert);
sk_PKCS12_SAFEBAG_pop_free(bags, PKCS12_SAFEBAG_free);
reqs = reqs->next;
}
if (error_count != 0)
goto end;
// Create the PKCS12 wrapper
p12 = PKCS12_add_safes(authsafes, 0);
if (!p12) {
certutil_updateErrorString();
goto end;
}
PKCS12_set_mac(p12, (char*)password, -1, NULL, 0, MAC_ITER, NULL);
// Save file
if (i2d_PKCS12_fp(file, p12)) {
error = TokenError_Success;
}
end:
sk_PKCS7_pop_free(authsafes, PKCS7_free);
PKCS12_free(p12);
return error;
}