| /* This Source Code Form is subject to the terms of the Mozilla Public |
| * License, v. 2.0. If a copy of the MPL was not distributed with this |
| * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
| |
| /* |
| * PKCS7 creation. |
| */ |
| |
| #include "p7local.h" |
| |
| #include "cert.h" |
| #include "secasn1.h" |
| #include "secitem.h" |
| #include "secoid.h" |
| #include "pk11func.h" |
| #include "prtime.h" |
| #include "secerr.h" |
| #include "secder.h" |
| #include "secpkcs5.h" |
| |
| const int NSS_PBE_DEFAULT_ITERATION_COUNT = 2000; /* used in p12e.c too */ |
| |
| static SECStatus |
| sec_pkcs7_init_content_info (SEC_PKCS7ContentInfo *cinfo, PLArenaPool *poolp, |
| SECOidTag kind, PRBool detached) |
| { |
| void *thing; |
| int version; |
| SECItem *versionp; |
| SECStatus rv; |
| |
| PORT_Assert (cinfo != NULL && poolp != NULL); |
| if (cinfo == NULL || poolp == NULL) |
| return SECFailure; |
| |
| cinfo->contentTypeTag = SECOID_FindOIDByTag (kind); |
| PORT_Assert (cinfo->contentTypeTag |
| && cinfo->contentTypeTag->offset == kind); |
| |
| rv = SECITEM_CopyItem (poolp, &(cinfo->contentType), |
| &(cinfo->contentTypeTag->oid)); |
| if (rv != SECSuccess) |
| return rv; |
| |
| if (detached) |
| return SECSuccess; |
| |
| switch (kind) { |
| default: |
| case SEC_OID_PKCS7_DATA: |
| thing = PORT_ArenaZAlloc (poolp, sizeof(SECItem)); |
| cinfo->content.data = (SECItem*)thing; |
| versionp = NULL; |
| version = -1; |
| break; |
| case SEC_OID_PKCS7_DIGESTED_DATA: |
| thing = PORT_ArenaZAlloc (poolp, sizeof(SEC_PKCS7DigestedData)); |
| cinfo->content.digestedData = (SEC_PKCS7DigestedData*)thing; |
| versionp = &(cinfo->content.digestedData->version); |
| version = SEC_PKCS7_DIGESTED_DATA_VERSION; |
| break; |
| case SEC_OID_PKCS7_ENCRYPTED_DATA: |
| thing = PORT_ArenaZAlloc (poolp, sizeof(SEC_PKCS7EncryptedData)); |
| cinfo->content.encryptedData = (SEC_PKCS7EncryptedData*)thing; |
| versionp = &(cinfo->content.encryptedData->version); |
| version = SEC_PKCS7_ENCRYPTED_DATA_VERSION; |
| break; |
| case SEC_OID_PKCS7_ENVELOPED_DATA: |
| thing = PORT_ArenaZAlloc (poolp, sizeof(SEC_PKCS7EnvelopedData)); |
| cinfo->content.envelopedData = |
| (SEC_PKCS7EnvelopedData*)thing; |
| versionp = &(cinfo->content.envelopedData->version); |
| version = SEC_PKCS7_ENVELOPED_DATA_VERSION; |
| break; |
| case SEC_OID_PKCS7_SIGNED_DATA: |
| thing = PORT_ArenaZAlloc (poolp, sizeof(SEC_PKCS7SignedData)); |
| cinfo->content.signedData = |
| (SEC_PKCS7SignedData*)thing; |
| versionp = &(cinfo->content.signedData->version); |
| version = SEC_PKCS7_SIGNED_DATA_VERSION; |
| break; |
| case SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA: |
| thing = PORT_ArenaZAlloc(poolp,sizeof(SEC_PKCS7SignedAndEnvelopedData)); |
| cinfo->content.signedAndEnvelopedData = |
| (SEC_PKCS7SignedAndEnvelopedData*)thing; |
| versionp = &(cinfo->content.signedAndEnvelopedData->version); |
| version = SEC_PKCS7_SIGNED_AND_ENVELOPED_DATA_VERSION; |
| break; |
| } |
| |
| if (thing == NULL) |
| return SECFailure; |
| |
| if (versionp != NULL) { |
| SECItem *dummy; |
| |
| PORT_Assert (version >= 0); |
| dummy = SEC_ASN1EncodeInteger (poolp, versionp, version); |
| if (dummy == NULL) |
| return SECFailure; |
| PORT_Assert (dummy == versionp); |
| } |
| |
| return SECSuccess; |
| } |
| |
| |
| static SEC_PKCS7ContentInfo * |
| sec_pkcs7_create_content_info (SECOidTag kind, PRBool detached, |
| SECKEYGetPasswordKey pwfn, void *pwfn_arg) |
| { |
| SEC_PKCS7ContentInfo *cinfo; |
| PLArenaPool *poolp; |
| SECStatus rv; |
| |
| poolp = PORT_NewArena (1024); /* XXX what is right value? */ |
| if (poolp == NULL) |
| return NULL; |
| |
| cinfo = (SEC_PKCS7ContentInfo*)PORT_ArenaZAlloc (poolp, sizeof(*cinfo)); |
| if (cinfo == NULL) { |
| PORT_FreeArena (poolp, PR_FALSE); |
| return NULL; |
| } |
| |
| cinfo->poolp = poolp; |
| cinfo->pwfn = pwfn; |
| cinfo->pwfn_arg = pwfn_arg; |
| cinfo->created = PR_TRUE; |
| cinfo->refCount = 1; |
| |
| rv = sec_pkcs7_init_content_info (cinfo, poolp, kind, detached); |
| if (rv != SECSuccess) { |
| PORT_FreeArena (poolp, PR_FALSE); |
| return NULL; |
| } |
| |
| return cinfo; |
| } |
| |
| |
| /* |
| * Add a signer to a PKCS7 thing, verifying the signature cert first. |
| * Any error returns SECFailure. |
| * |
| * XXX Right now this only adds the *first* signer. It fails if you try |
| * to add a second one -- this needs to be fixed. |
| */ |
| static SECStatus |
| sec_pkcs7_add_signer (SEC_PKCS7ContentInfo *cinfo, |
| CERTCertificate * cert, |
| SECCertUsage certusage, |
| CERTCertDBHandle * certdb, |
| SECOidTag digestalgtag, |
| SECItem * digestdata) |
| { |
| SEC_PKCS7SignerInfo *signerinfo, **signerinfos, ***signerinfosp; |
| SECAlgorithmID *digestalg, **digestalgs, ***digestalgsp; |
| SECItem *digest, **digests, ***digestsp; |
| SECItem * dummy; |
| void * mark; |
| SECStatus rv; |
| SECOidTag kind; |
| |
| kind = SEC_PKCS7ContentType (cinfo); |
| switch (kind) { |
| case SEC_OID_PKCS7_SIGNED_DATA: |
| { |
| SEC_PKCS7SignedData *sdp; |
| |
| sdp = cinfo->content.signedData; |
| digestalgsp = &(sdp->digestAlgorithms); |
| digestsp = &(sdp->digests); |
| signerinfosp = &(sdp->signerInfos); |
| } |
| break; |
| case SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA: |
| { |
| SEC_PKCS7SignedAndEnvelopedData *saedp; |
| |
| saedp = cinfo->content.signedAndEnvelopedData; |
| digestalgsp = &(saedp->digestAlgorithms); |
| digestsp = &(saedp->digests); |
| signerinfosp = &(saedp->signerInfos); |
| } |
| break; |
| default: |
| return SECFailure; /* XXX set an error? */ |
| } |
| |
| /* |
| * XXX I think that CERT_VerifyCert should do this if *it* is passed |
| * a NULL database. |
| */ |
| if (certdb == NULL) { |
| certdb = CERT_GetDefaultCertDB(); |
| if (certdb == NULL) |
| return SECFailure; /* XXX set an error? */ |
| } |
| |
| if (CERT_VerifyCert (certdb, cert, PR_TRUE, certusage, PR_Now(), |
| cinfo->pwfn_arg, NULL) != SECSuccess) |
| { |
| /* XXX Did CERT_VerifyCert set an error? */ |
| return SECFailure; |
| } |
| |
| /* |
| * XXX This is the check that we do not already have a signer. |
| * This is not what we really want -- we want to allow this |
| * and *add* the new signer. |
| */ |
| PORT_Assert (*signerinfosp == NULL |
| && *digestalgsp == NULL && *digestsp == NULL); |
| if (*signerinfosp != NULL || *digestalgsp != NULL || *digestsp != NULL) |
| return SECFailure; |
| |
| mark = PORT_ArenaMark (cinfo->poolp); |
| |
| signerinfo = (SEC_PKCS7SignerInfo*)PORT_ArenaZAlloc (cinfo->poolp, |
| sizeof(SEC_PKCS7SignerInfo)); |
| if (signerinfo == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| |
| dummy = SEC_ASN1EncodeInteger (cinfo->poolp, &signerinfo->version, |
| SEC_PKCS7_SIGNER_INFO_VERSION); |
| if (dummy == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| PORT_Assert (dummy == &signerinfo->version); |
| |
| signerinfo->cert = CERT_DupCertificate (cert); |
| if (signerinfo->cert == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| |
| signerinfo->issuerAndSN = CERT_GetCertIssuerAndSN (cinfo->poolp, cert); |
| if (signerinfo->issuerAndSN == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| |
| rv = SECOID_SetAlgorithmID (cinfo->poolp, &signerinfo->digestAlg, |
| digestalgtag, NULL); |
| if (rv != SECSuccess) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| |
| /* |
| * Okay, now signerinfo is all set. We just need to put it and its |
| * companions (another copy of the digest algorithm, and the digest |
| * itself if given) into the main structure. |
| * |
| * XXX If we are handling more than one signer, the following code |
| * needs to look through the digest algorithms already specified |
| * and see if the same one is there already. If it is, it does not |
| * need to be added again. Also, if it is there *and* the digest |
| * is not null, then the digest given should match the digest already |
| * specified -- if not, that is an error. Finally, the new signerinfo |
| * should be *added* to the set already found. |
| */ |
| |
| signerinfos = (SEC_PKCS7SignerInfo**)PORT_ArenaAlloc (cinfo->poolp, |
| 2 * sizeof(SEC_PKCS7SignerInfo *)); |
| if (signerinfos == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| signerinfos[0] = signerinfo; |
| signerinfos[1] = NULL; |
| |
| digestalg = PORT_ArenaZAlloc (cinfo->poolp, sizeof(SECAlgorithmID)); |
| digestalgs = PORT_ArenaAlloc (cinfo->poolp, 2 * sizeof(SECAlgorithmID *)); |
| if (digestalg == NULL || digestalgs == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| rv = SECOID_SetAlgorithmID (cinfo->poolp, digestalg, digestalgtag, NULL); |
| if (rv != SECSuccess) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| digestalgs[0] = digestalg; |
| digestalgs[1] = NULL; |
| |
| if (digestdata != NULL) { |
| digest = (SECItem*)PORT_ArenaAlloc (cinfo->poolp, sizeof(SECItem)); |
| digests = (SECItem**)PORT_ArenaAlloc (cinfo->poolp, |
| 2 * sizeof(SECItem *)); |
| if (digest == NULL || digests == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| rv = SECITEM_CopyItem (cinfo->poolp, digest, digestdata); |
| if (rv != SECSuccess) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| digests[0] = digest; |
| digests[1] = NULL; |
| } else { |
| digests = NULL; |
| } |
| |
| *signerinfosp = signerinfos; |
| *digestalgsp = digestalgs; |
| *digestsp = digests; |
| |
| PORT_ArenaUnmark(cinfo->poolp, mark); |
| return SECSuccess; |
| } |
| |
| |
| /* |
| * Helper function for creating an empty signedData. |
| */ |
| static SEC_PKCS7ContentInfo * |
| sec_pkcs7_create_signed_data (SECKEYGetPasswordKey pwfn, void *pwfn_arg) |
| { |
| SEC_PKCS7ContentInfo *cinfo; |
| SEC_PKCS7SignedData *sigd; |
| SECStatus rv; |
| |
| cinfo = sec_pkcs7_create_content_info (SEC_OID_PKCS7_SIGNED_DATA, PR_FALSE, |
| pwfn, pwfn_arg); |
| if (cinfo == NULL) |
| return NULL; |
| |
| sigd = cinfo->content.signedData; |
| PORT_Assert (sigd != NULL); |
| |
| /* |
| * XXX Might we want to allow content types other than data? |
| * If so, via what interface? |
| */ |
| rv = sec_pkcs7_init_content_info (&(sigd->contentInfo), cinfo->poolp, |
| SEC_OID_PKCS7_DATA, PR_TRUE); |
| if (rv != SECSuccess) { |
| SEC_PKCS7DestroyContentInfo (cinfo); |
| return NULL; |
| } |
| |
| return cinfo; |
| } |
| |
| |
| /* |
| * Start a PKCS7 signing context. |
| * |
| * "cert" is the cert that will be used to sign the data. It will be |
| * checked for validity. |
| * |
| * "certusage" describes the signing usage (e.g. certUsageEmailSigner) |
| * XXX Maybe SECCertUsage should be split so that our caller just says |
| * "email" and *we* add the "signing" part -- otherwise our caller |
| * could be lying about the usage; we do not want to allow encryption |
| * certs for signing or vice versa. |
| * |
| * "certdb" is the cert database to use for verifying the cert. |
| * It can be NULL if a default database is available (like in the client). |
| * |
| * "digestalg" names the digest algorithm (e.g. SEC_OID_SHA1). |
| * |
| * "digest" is the actual digest of the data. It must be provided in |
| * the case of detached data or NULL if the content will be included. |
| * |
| * The return value can be passed to functions which add things to |
| * it like attributes, then eventually to SEC_PKCS7Encode() or to |
| * SEC_PKCS7EncoderStart() to create the encoded data, and finally to |
| * SEC_PKCS7DestroyContentInfo(). |
| * |
| * An error results in a return value of NULL and an error set. |
| * (Retrieve specific errors via PORT_GetError()/XP_GetError().) |
| */ |
| SEC_PKCS7ContentInfo * |
| SEC_PKCS7CreateSignedData (CERTCertificate *cert, |
| SECCertUsage certusage, |
| CERTCertDBHandle *certdb, |
| SECOidTag digestalg, |
| SECItem *digest, |
| SECKEYGetPasswordKey pwfn, void *pwfn_arg) |
| { |
| SEC_PKCS7ContentInfo *cinfo; |
| SECStatus rv; |
| |
| cinfo = sec_pkcs7_create_signed_data (pwfn, pwfn_arg); |
| if (cinfo == NULL) |
| return NULL; |
| |
| rv = sec_pkcs7_add_signer (cinfo, cert, certusage, certdb, |
| digestalg, digest); |
| if (rv != SECSuccess) { |
| SEC_PKCS7DestroyContentInfo (cinfo); |
| return NULL; |
| } |
| |
| return cinfo; |
| } |
| |
| |
| static SEC_PKCS7Attribute * |
| sec_pkcs7_create_attribute (PLArenaPool *poolp, SECOidTag oidtag, |
| SECItem *value, PRBool encoded) |
| { |
| SEC_PKCS7Attribute *attr; |
| SECItem **values; |
| void *mark; |
| |
| PORT_Assert (poolp != NULL); |
| mark = PORT_ArenaMark (poolp); |
| |
| attr = (SEC_PKCS7Attribute*)PORT_ArenaAlloc (poolp, |
| sizeof(SEC_PKCS7Attribute)); |
| if (attr == NULL) |
| goto loser; |
| |
| attr->typeTag = SECOID_FindOIDByTag (oidtag); |
| if (attr->typeTag == NULL) |
| goto loser; |
| |
| if (SECITEM_CopyItem (poolp, &(attr->type), |
| &(attr->typeTag->oid)) != SECSuccess) |
| goto loser; |
| |
| values = (SECItem**)PORT_ArenaAlloc (poolp, 2 * sizeof(SECItem *)); |
| if (values == NULL) |
| goto loser; |
| |
| if (value != NULL) { |
| SECItem *copy; |
| |
| copy = (SECItem*)PORT_ArenaAlloc (poolp, sizeof(SECItem)); |
| if (copy == NULL) |
| goto loser; |
| |
| if (SECITEM_CopyItem (poolp, copy, value) != SECSuccess) |
| goto loser; |
| |
| value = copy; |
| } |
| |
| values[0] = value; |
| values[1] = NULL; |
| attr->values = values; |
| attr->encoded = encoded; |
| |
| PORT_ArenaUnmark (poolp, mark); |
| return attr; |
| |
| loser: |
| PORT_Assert (mark != NULL); |
| PORT_ArenaRelease (poolp, mark); |
| return NULL; |
| } |
| |
| |
| static SECStatus |
| sec_pkcs7_add_attribute (SEC_PKCS7ContentInfo *cinfo, |
| SEC_PKCS7Attribute ***attrsp, |
| SEC_PKCS7Attribute *attr) |
| { |
| SEC_PKCS7Attribute **attrs; |
| SECItem *ct_value; |
| void *mark; |
| |
| PORT_Assert (SEC_PKCS7ContentType (cinfo) == SEC_OID_PKCS7_SIGNED_DATA); |
| if (SEC_PKCS7ContentType (cinfo) != SEC_OID_PKCS7_SIGNED_DATA) |
| return SECFailure; |
| |
| attrs = *attrsp; |
| if (attrs != NULL) { |
| int count; |
| |
| /* |
| * We already have some attributes, and just need to add this |
| * new one. |
| */ |
| |
| /* |
| * We should already have the *required* attributes, which were |
| * created/added at the same time the first attribute was added. |
| */ |
| PORT_Assert (sec_PKCS7FindAttribute (attrs, |
| SEC_OID_PKCS9_CONTENT_TYPE, |
| PR_FALSE) != NULL); |
| PORT_Assert (sec_PKCS7FindAttribute (attrs, |
| SEC_OID_PKCS9_MESSAGE_DIGEST, |
| PR_FALSE) != NULL); |
| |
| for (count = 0; attrs[count] != NULL; count++) |
| ; |
| attrs = (SEC_PKCS7Attribute**)PORT_ArenaGrow (cinfo->poolp, attrs, |
| (count + 1) * sizeof(SEC_PKCS7Attribute *), |
| (count + 2) * sizeof(SEC_PKCS7Attribute *)); |
| if (attrs == NULL) |
| return SECFailure; |
| |
| attrs[count] = attr; |
| attrs[count+1] = NULL; |
| *attrsp = attrs; |
| |
| return SECSuccess; |
| } |
| |
| /* |
| * This is the first time an attribute is going in. |
| * We need to create and add the required attributes, and then |
| * we will also add in the one our caller gave us. |
| */ |
| |
| /* |
| * There are 2 required attributes, plus the one our caller wants |
| * to add, plus we always end with a NULL one. Thus, four slots. |
| */ |
| attrs = (SEC_PKCS7Attribute**)PORT_ArenaAlloc (cinfo->poolp, |
| 4 * sizeof(SEC_PKCS7Attribute *)); |
| if (attrs == NULL) |
| return SECFailure; |
| |
| mark = PORT_ArenaMark (cinfo->poolp); |
| |
| /* |
| * First required attribute is the content type of the data |
| * being signed. |
| */ |
| ct_value = &(cinfo->content.signedData->contentInfo.contentType); |
| attrs[0] = sec_pkcs7_create_attribute (cinfo->poolp, |
| SEC_OID_PKCS9_CONTENT_TYPE, |
| ct_value, PR_FALSE); |
| /* |
| * Second required attribute is the message digest of the data |
| * being signed; we leave the value NULL for now (just create |
| * the place for it to go), and the encoder will fill it in later. |
| */ |
| attrs[1] = sec_pkcs7_create_attribute (cinfo->poolp, |
| SEC_OID_PKCS9_MESSAGE_DIGEST, |
| NULL, PR_FALSE); |
| if (attrs[0] == NULL || attrs[1] == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| |
| attrs[2] = attr; |
| attrs[3] = NULL; |
| *attrsp = attrs; |
| |
| PORT_ArenaUnmark (cinfo->poolp, mark); |
| return SECSuccess; |
| } |
| |
| |
| /* |
| * Add the signing time to the authenticated (i.e. signed) attributes |
| * of "cinfo". This is expected to be included in outgoing signed |
| * messages for email (S/MIME) but is likely useful in other situations. |
| * |
| * This should only be added once; a second call will either do |
| * nothing or replace an old signing time with a newer one. |
| * |
| * XXX This will probably just shove the current time into "cinfo" |
| * but it will not actually get signed until the entire item is |
| * processed for encoding. Is this (expected to be small) delay okay? |
| * |
| * "cinfo" should be of type signedData (the only kind of pkcs7 data |
| * that is allowed authenticated attributes); SECFailure will be returned |
| * if it is not. |
| */ |
| SECStatus |
| SEC_PKCS7AddSigningTime (SEC_PKCS7ContentInfo *cinfo) |
| { |
| SEC_PKCS7SignerInfo **signerinfos; |
| SEC_PKCS7Attribute *attr; |
| SECItem stime; |
| SECStatus rv; |
| int si; |
| |
| PORT_Assert (SEC_PKCS7ContentType (cinfo) == SEC_OID_PKCS7_SIGNED_DATA); |
| if (SEC_PKCS7ContentType (cinfo) != SEC_OID_PKCS7_SIGNED_DATA) |
| return SECFailure; |
| |
| signerinfos = cinfo->content.signedData->signerInfos; |
| |
| /* There has to be a signer, or it makes no sense. */ |
| if (signerinfos == NULL || signerinfos[0] == NULL) |
| return SECFailure; |
| |
| rv = DER_EncodeTimeChoice(NULL, &stime, PR_Now()); |
| if (rv != SECSuccess) |
| return rv; |
| |
| attr = sec_pkcs7_create_attribute (cinfo->poolp, |
| SEC_OID_PKCS9_SIGNING_TIME, |
| &stime, PR_FALSE); |
| SECITEM_FreeItem (&stime, PR_FALSE); |
| |
| if (attr == NULL) |
| return SECFailure; |
| |
| rv = SECSuccess; |
| for (si = 0; signerinfos[si] != NULL; si++) { |
| SEC_PKCS7Attribute *oattr; |
| |
| oattr = sec_PKCS7FindAttribute (signerinfos[si]->authAttr, |
| SEC_OID_PKCS9_SIGNING_TIME, PR_FALSE); |
| PORT_Assert (oattr == NULL); |
| if (oattr != NULL) |
| continue; /* XXX or would it be better to replace it? */ |
| |
| rv = sec_pkcs7_add_attribute (cinfo, &(signerinfos[si]->authAttr), |
| attr); |
| if (rv != SECSuccess) |
| break; /* could try to continue, but may as well give up now */ |
| } |
| |
| return rv; |
| } |
| |
| |
| /* |
| * Add the specified attribute to the authenticated (i.e. signed) attributes |
| * of "cinfo" -- "oidtag" describes the attribute and "value" is the |
| * value to be associated with it. NOTE! "value" must already be encoded; |
| * no interpretation of "oidtag" is done. Also, it is assumed that this |
| * signedData has only one signer -- if we ever need to add attributes |
| * when there is more than one signature, we need a way to specify *which* |
| * signature should get the attribute. |
| * |
| * XXX Technically, a signed attribute can have multiple values; if/when |
| * we ever need to support an attribute which takes multiple values, we |
| * either need to change this interface or create an AddSignedAttributeValue |
| * which can be called subsequently, and would then append a value. |
| * |
| * "cinfo" should be of type signedData (the only kind of pkcs7 data |
| * that is allowed authenticated attributes); SECFailure will be returned |
| * if it is not. |
| */ |
| SECStatus |
| SEC_PKCS7AddSignedAttribute (SEC_PKCS7ContentInfo *cinfo, |
| SECOidTag oidtag, |
| SECItem *value) |
| { |
| SEC_PKCS7SignerInfo **signerinfos; |
| SEC_PKCS7Attribute *attr; |
| |
| PORT_Assert (SEC_PKCS7ContentType (cinfo) == SEC_OID_PKCS7_SIGNED_DATA); |
| if (SEC_PKCS7ContentType (cinfo) != SEC_OID_PKCS7_SIGNED_DATA) |
| return SECFailure; |
| |
| signerinfos = cinfo->content.signedData->signerInfos; |
| |
| /* |
| * No signature or more than one means no deal. |
| */ |
| if (signerinfos == NULL || signerinfos[0] == NULL || signerinfos[1] != NULL) |
| return SECFailure; |
| |
| attr = sec_pkcs7_create_attribute (cinfo->poolp, oidtag, value, PR_TRUE); |
| if (attr == NULL) |
| return SECFailure; |
| |
| return sec_pkcs7_add_attribute (cinfo, &(signerinfos[0]->authAttr), attr); |
| } |
| |
| |
| /* |
| * Mark that the signer certificates and their issuing chain should |
| * be included in the encoded data. This is expected to be used |
| * in outgoing signed messages for email (S/MIME). |
| * |
| * "certdb" is the cert database to use for finding the chain. |
| * It can be NULL, meaning use the default database. |
| * |
| * "cinfo" should be of type signedData or signedAndEnvelopedData; |
| * SECFailure will be returned if it is not. |
| */ |
| SECStatus |
| SEC_PKCS7IncludeCertChain (SEC_PKCS7ContentInfo *cinfo, |
| CERTCertDBHandle *certdb) |
| { |
| SECOidTag kind; |
| SEC_PKCS7SignerInfo *signerinfo, **signerinfos; |
| |
| kind = SEC_PKCS7ContentType (cinfo); |
| switch (kind) { |
| case SEC_OID_PKCS7_SIGNED_DATA: |
| signerinfos = cinfo->content.signedData->signerInfos; |
| break; |
| case SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA: |
| signerinfos = cinfo->content.signedAndEnvelopedData->signerInfos; |
| break; |
| default: |
| return SECFailure; /* XXX set an error? */ |
| } |
| |
| if (signerinfos == NULL) /* no signer, no certs? */ |
| return SECFailure; /* XXX set an error? */ |
| |
| if (certdb == NULL) { |
| certdb = CERT_GetDefaultCertDB(); |
| if (certdb == NULL) { |
| PORT_SetError (SEC_ERROR_BAD_DATABASE); |
| return SECFailure; |
| } |
| } |
| |
| /* XXX Should it be an error if we find no signerinfo or no certs? */ |
| while ((signerinfo = *signerinfos++) != NULL) { |
| if (signerinfo->cert != NULL) |
| /* get the cert chain. don't send the root to avoid contamination |
| * of old clients with a new root that they don't trust |
| */ |
| signerinfo->certList = CERT_CertChainFromCert (signerinfo->cert, |
| certUsageEmailSigner, |
| PR_FALSE); |
| } |
| |
| return SECSuccess; |
| } |
| |
| |
| /* |
| * Helper function to add a certificate chain for inclusion in the |
| * bag of certificates in a signedData. |
| */ |
| static SECStatus |
| sec_pkcs7_add_cert_chain (SEC_PKCS7ContentInfo *cinfo, |
| CERTCertificate *cert, |
| CERTCertDBHandle *certdb) |
| { |
| SECOidTag kind; |
| CERTCertificateList *certlist, **certlists, ***certlistsp; |
| int count; |
| |
| kind = SEC_PKCS7ContentType (cinfo); |
| switch (kind) { |
| case SEC_OID_PKCS7_SIGNED_DATA: |
| { |
| SEC_PKCS7SignedData *sdp; |
| |
| sdp = cinfo->content.signedData; |
| certlistsp = &(sdp->certLists); |
| } |
| break; |
| case SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA: |
| { |
| SEC_PKCS7SignedAndEnvelopedData *saedp; |
| |
| saedp = cinfo->content.signedAndEnvelopedData; |
| certlistsp = &(saedp->certLists); |
| } |
| break; |
| default: |
| return SECFailure; /* XXX set an error? */ |
| } |
| |
| if (certdb == NULL) { |
| certdb = CERT_GetDefaultCertDB(); |
| if (certdb == NULL) { |
| PORT_SetError (SEC_ERROR_BAD_DATABASE); |
| return SECFailure; |
| } |
| } |
| |
| certlist = CERT_CertChainFromCert (cert, certUsageEmailSigner, PR_FALSE); |
| if (certlist == NULL) |
| return SECFailure; |
| |
| certlists = *certlistsp; |
| if (certlists == NULL) { |
| count = 0; |
| certlists = (CERTCertificateList**)PORT_ArenaAlloc (cinfo->poolp, |
| 2 * sizeof(CERTCertificateList *)); |
| } else { |
| for (count = 0; certlists[count] != NULL; count++) |
| ; |
| PORT_Assert (count); /* should be at least one already */ |
| certlists = (CERTCertificateList**)PORT_ArenaGrow (cinfo->poolp, |
| certlists, |
| (count + 1) * sizeof(CERTCertificateList *), |
| (count + 2) * sizeof(CERTCertificateList *)); |
| } |
| |
| if (certlists == NULL) { |
| CERT_DestroyCertificateList (certlist); |
| return SECFailure; |
| } |
| |
| certlists[count] = certlist; |
| certlists[count + 1] = NULL; |
| |
| *certlistsp = certlists; |
| |
| return SECSuccess; |
| } |
| |
| |
| /* |
| * Helper function to add a certificate for inclusion in the bag of |
| * certificates in a signedData. |
| */ |
| static SECStatus |
| sec_pkcs7_add_certificate (SEC_PKCS7ContentInfo *cinfo, |
| CERTCertificate *cert) |
| { |
| SECOidTag kind; |
| CERTCertificate **certs, ***certsp; |
| int count; |
| |
| kind = SEC_PKCS7ContentType (cinfo); |
| switch (kind) { |
| case SEC_OID_PKCS7_SIGNED_DATA: |
| { |
| SEC_PKCS7SignedData *sdp; |
| |
| sdp = cinfo->content.signedData; |
| certsp = &(sdp->certs); |
| } |
| break; |
| case SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA: |
| { |
| SEC_PKCS7SignedAndEnvelopedData *saedp; |
| |
| saedp = cinfo->content.signedAndEnvelopedData; |
| certsp = &(saedp->certs); |
| } |
| break; |
| default: |
| return SECFailure; /* XXX set an error? */ |
| } |
| |
| cert = CERT_DupCertificate (cert); |
| if (cert == NULL) |
| return SECFailure; |
| |
| certs = *certsp; |
| if (certs == NULL) { |
| count = 0; |
| certs = (CERTCertificate**)PORT_ArenaAlloc (cinfo->poolp, |
| 2 * sizeof(CERTCertificate *)); |
| } else { |
| for (count = 0; certs[count] != NULL; count++) |
| ; |
| PORT_Assert (count); /* should be at least one already */ |
| certs = (CERTCertificate**)PORT_ArenaGrow (cinfo->poolp, certs, |
| (count + 1) * sizeof(CERTCertificate *), |
| (count + 2) * sizeof(CERTCertificate *)); |
| } |
| |
| if (certs == NULL) { |
| CERT_DestroyCertificate (cert); |
| return SECFailure; |
| } |
| |
| certs[count] = cert; |
| certs[count + 1] = NULL; |
| |
| *certsp = certs; |
| |
| return SECSuccess; |
| } |
| |
| |
| /* |
| * Create a PKCS7 certs-only container. |
| * |
| * "cert" is the (first) cert that will be included. |
| * |
| * "include_chain" specifies whether the entire chain for "cert" should |
| * be included. |
| * |
| * "certdb" is the cert database to use for finding the chain. |
| * It can be NULL in when "include_chain" is false, or when meaning |
| * use the default database. |
| * |
| * More certs and chains can be added via AddCertificate and AddCertChain. |
| * |
| * An error results in a return value of NULL and an error set. |
| * (Retrieve specific errors via PORT_GetError()/XP_GetError().) |
| */ |
| SEC_PKCS7ContentInfo * |
| SEC_PKCS7CreateCertsOnly (CERTCertificate *cert, |
| PRBool include_chain, |
| CERTCertDBHandle *certdb) |
| { |
| SEC_PKCS7ContentInfo *cinfo; |
| SECStatus rv; |
| |
| cinfo = sec_pkcs7_create_signed_data (NULL, NULL); |
| if (cinfo == NULL) |
| return NULL; |
| |
| if (include_chain) |
| rv = sec_pkcs7_add_cert_chain (cinfo, cert, certdb); |
| else |
| rv = sec_pkcs7_add_certificate (cinfo, cert); |
| |
| if (rv != SECSuccess) { |
| SEC_PKCS7DestroyContentInfo (cinfo); |
| return NULL; |
| } |
| |
| return cinfo; |
| } |
| |
| |
| /* |
| * Add "cert" and its entire chain to the set of certs included in "cinfo". |
| * |
| * "certdb" is the cert database to use for finding the chain. |
| * It can be NULL, meaning use the default database. |
| * |
| * "cinfo" should be of type signedData or signedAndEnvelopedData; |
| * SECFailure will be returned if it is not. |
| */ |
| SECStatus |
| SEC_PKCS7AddCertChain (SEC_PKCS7ContentInfo *cinfo, |
| CERTCertificate *cert, |
| CERTCertDBHandle *certdb) |
| { |
| SECOidTag kind; |
| |
| kind = SEC_PKCS7ContentType (cinfo); |
| if (kind != SEC_OID_PKCS7_SIGNED_DATA |
| && kind != SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA) |
| return SECFailure; /* XXX set an error? */ |
| |
| return sec_pkcs7_add_cert_chain (cinfo, cert, certdb); |
| } |
| |
| |
| /* |
| * Add "cert" to the set of certs included in "cinfo". |
| * |
| * "cinfo" should be of type signedData or signedAndEnvelopedData; |
| * SECFailure will be returned if it is not. |
| */ |
| SECStatus |
| SEC_PKCS7AddCertificate (SEC_PKCS7ContentInfo *cinfo, CERTCertificate *cert) |
| { |
| SECOidTag kind; |
| |
| kind = SEC_PKCS7ContentType (cinfo); |
| if (kind != SEC_OID_PKCS7_SIGNED_DATA |
| && kind != SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA) |
| return SECFailure; /* XXX set an error? */ |
| |
| return sec_pkcs7_add_certificate (cinfo, cert); |
| } |
| |
| |
| static SECStatus |
| sec_pkcs7_init_encrypted_content_info (SEC_PKCS7EncryptedContentInfo *enccinfo, |
| PLArenaPool *poolp, |
| SECOidTag kind, PRBool detached, |
| SECOidTag encalg, int keysize) |
| { |
| SECStatus rv; |
| |
| PORT_Assert (enccinfo != NULL && poolp != NULL); |
| if (enccinfo == NULL || poolp == NULL) |
| return SECFailure; |
| |
| /* |
| * XXX Some day we may want to allow for other kinds. That needs |
| * more work and modifications to the creation interface, etc. |
| * For now, allow but notice callers who pass in other kinds. |
| * They are responsible for creating the inner type and encoding, |
| * if it is other than DATA. |
| */ |
| PORT_Assert (kind == SEC_OID_PKCS7_DATA); |
| |
| enccinfo->contentTypeTag = SECOID_FindOIDByTag (kind); |
| PORT_Assert (enccinfo->contentTypeTag |
| && enccinfo->contentTypeTag->offset == kind); |
| |
| rv = SECITEM_CopyItem (poolp, &(enccinfo->contentType), |
| &(enccinfo->contentTypeTag->oid)); |
| if (rv != SECSuccess) |
| return rv; |
| |
| /* Save keysize and algorithm for later. */ |
| enccinfo->keysize = keysize; |
| enccinfo->encalg = encalg; |
| |
| return SECSuccess; |
| } |
| |
| |
| /* |
| * Add a recipient to a PKCS7 thing, verifying their cert first. |
| * Any error returns SECFailure. |
| */ |
| static SECStatus |
| sec_pkcs7_add_recipient (SEC_PKCS7ContentInfo *cinfo, |
| CERTCertificate *cert, |
| SECCertUsage certusage, |
| CERTCertDBHandle *certdb) |
| { |
| SECOidTag kind; |
| SEC_PKCS7RecipientInfo *recipientinfo, **recipientinfos, ***recipientinfosp; |
| SECItem *dummy; |
| void *mark; |
| int count; |
| |
| kind = SEC_PKCS7ContentType (cinfo); |
| switch (kind) { |
| case SEC_OID_PKCS7_ENVELOPED_DATA: |
| { |
| SEC_PKCS7EnvelopedData *edp; |
| |
| edp = cinfo->content.envelopedData; |
| recipientinfosp = &(edp->recipientInfos); |
| } |
| break; |
| case SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA: |
| { |
| SEC_PKCS7SignedAndEnvelopedData *saedp; |
| |
| saedp = cinfo->content.signedAndEnvelopedData; |
| recipientinfosp = &(saedp->recipientInfos); |
| } |
| break; |
| default: |
| return SECFailure; /* XXX set an error? */ |
| } |
| |
| /* |
| * XXX I think that CERT_VerifyCert should do this if *it* is passed |
| * a NULL database. |
| */ |
| if (certdb == NULL) { |
| certdb = CERT_GetDefaultCertDB(); |
| if (certdb == NULL) |
| return SECFailure; /* XXX set an error? */ |
| } |
| |
| if (CERT_VerifyCert (certdb, cert, PR_TRUE, certusage, PR_Now(), |
| cinfo->pwfn_arg, NULL) != SECSuccess) |
| { |
| /* XXX Did CERT_VerifyCert set an error? */ |
| return SECFailure; |
| } |
| |
| mark = PORT_ArenaMark (cinfo->poolp); |
| |
| recipientinfo = (SEC_PKCS7RecipientInfo*)PORT_ArenaZAlloc (cinfo->poolp, |
| sizeof(SEC_PKCS7RecipientInfo)); |
| if (recipientinfo == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| |
| dummy = SEC_ASN1EncodeInteger (cinfo->poolp, &recipientinfo->version, |
| SEC_PKCS7_RECIPIENT_INFO_VERSION); |
| if (dummy == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| PORT_Assert (dummy == &recipientinfo->version); |
| |
| recipientinfo->cert = CERT_DupCertificate (cert); |
| if (recipientinfo->cert == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| |
| recipientinfo->issuerAndSN = CERT_GetCertIssuerAndSN (cinfo->poolp, cert); |
| if (recipientinfo->issuerAndSN == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| |
| /* |
| * Okay, now recipientinfo is all set. We just need to put it into |
| * the main structure. |
| * |
| * If this is the first recipient, allocate a new recipientinfos array; |
| * otherwise, reallocate the array, making room for the new entry. |
| */ |
| recipientinfos = *recipientinfosp; |
| if (recipientinfos == NULL) { |
| count = 0; |
| recipientinfos = (SEC_PKCS7RecipientInfo **)PORT_ArenaAlloc ( |
| cinfo->poolp, |
| 2 * sizeof(SEC_PKCS7RecipientInfo *)); |
| } else { |
| for (count = 0; recipientinfos[count] != NULL; count++) |
| ; |
| PORT_Assert (count); /* should be at least one already */ |
| recipientinfos = (SEC_PKCS7RecipientInfo **)PORT_ArenaGrow ( |
| cinfo->poolp, recipientinfos, |
| (count + 1) * sizeof(SEC_PKCS7RecipientInfo *), |
| (count + 2) * sizeof(SEC_PKCS7RecipientInfo *)); |
| } |
| |
| if (recipientinfos == NULL) { |
| PORT_ArenaRelease (cinfo->poolp, mark); |
| return SECFailure; |
| } |
| |
| recipientinfos[count] = recipientinfo; |
| recipientinfos[count + 1] = NULL; |
| |
| *recipientinfosp = recipientinfos; |
| |
| PORT_ArenaUnmark (cinfo->poolp, mark); |
| return SECSuccess; |
| } |
| |
| |
| /* |
| * Start a PKCS7 enveloping context. |
| * |
| * "cert" is the cert for the recipient. It will be checked for validity. |
| * |
| * "certusage" describes the encryption usage (e.g. certUsageEmailRecipient) |
| * XXX Maybe SECCertUsage should be split so that our caller just says |
| * "email" and *we* add the "recipient" part -- otherwise our caller |
| * could be lying about the usage; we do not want to allow encryption |
| * certs for signing or vice versa. |
| * |
| * "certdb" is the cert database to use for verifying the cert. |
| * It can be NULL if a default database is available (like in the client). |
| * |
| * "encalg" specifies the bulk encryption algorithm to use (e.g. SEC_OID_RC2). |
| * |
| * "keysize" specifies the bulk encryption key size, in bits. |
| * |
| * The return value can be passed to functions which add things to |
| * it like more recipients, then eventually to SEC_PKCS7Encode() or to |
| * SEC_PKCS7EncoderStart() to create the encoded data, and finally to |
| * SEC_PKCS7DestroyContentInfo(). |
| * |
| * An error results in a return value of NULL and an error set. |
| * (Retrieve specific errors via PORT_GetError()/XP_GetError().) |
| */ |
| extern SEC_PKCS7ContentInfo * |
| SEC_PKCS7CreateEnvelopedData (CERTCertificate *cert, |
| SECCertUsage certusage, |
| CERTCertDBHandle *certdb, |
| SECOidTag encalg, |
| int keysize, |
| SECKEYGetPasswordKey pwfn, void *pwfn_arg) |
| { |
| SEC_PKCS7ContentInfo *cinfo; |
| SEC_PKCS7EnvelopedData *envd; |
| SECStatus rv; |
| |
| cinfo = sec_pkcs7_create_content_info (SEC_OID_PKCS7_ENVELOPED_DATA, |
| PR_FALSE, pwfn, pwfn_arg); |
| if (cinfo == NULL) |
| return NULL; |
| |
| rv = sec_pkcs7_add_recipient (cinfo, cert, certusage, certdb); |
| if (rv != SECSuccess) { |
| SEC_PKCS7DestroyContentInfo (cinfo); |
| return NULL; |
| } |
| |
| envd = cinfo->content.envelopedData; |
| PORT_Assert (envd != NULL); |
| |
| /* |
| * XXX Might we want to allow content types other than data? |
| * If so, via what interface? |
| */ |
| rv = sec_pkcs7_init_encrypted_content_info (&(envd->encContentInfo), |
| cinfo->poolp, |
| SEC_OID_PKCS7_DATA, PR_FALSE, |
| encalg, keysize); |
| if (rv != SECSuccess) { |
| SEC_PKCS7DestroyContentInfo (cinfo); |
| return NULL; |
| } |
| |
| /* XXX Anything more to do here? */ |
| |
| return cinfo; |
| } |
| |
| |
| /* |
| * Add another recipient to an encrypted message. |
| * |
| * "cinfo" should be of type envelopedData or signedAndEnvelopedData; |
| * SECFailure will be returned if it is not. |
| * |
| * "cert" is the cert for the recipient. It will be checked for validity. |
| * |
| * "certusage" describes the encryption usage (e.g. certUsageEmailRecipient) |
| * XXX Maybe SECCertUsage should be split so that our caller just says |
| * "email" and *we* add the "recipient" part -- otherwise our caller |
| * could be lying about the usage; we do not want to allow encryption |
| * certs for signing or vice versa. |
| * |
| * "certdb" is the cert database to use for verifying the cert. |
| * It can be NULL if a default database is available (like in the client). |
| */ |
| SECStatus |
| SEC_PKCS7AddRecipient (SEC_PKCS7ContentInfo *cinfo, |
| CERTCertificate *cert, |
| SECCertUsage certusage, |
| CERTCertDBHandle *certdb) |
| { |
| return sec_pkcs7_add_recipient (cinfo, cert, certusage, certdb); |
| } |
| |
| |
| /* |
| * Create an empty PKCS7 data content info. |
| * |
| * An error results in a return value of NULL and an error set. |
| * (Retrieve specific errors via PORT_GetError()/XP_GetError().) |
| */ |
| SEC_PKCS7ContentInfo * |
| SEC_PKCS7CreateData (void) |
| { |
| return sec_pkcs7_create_content_info (SEC_OID_PKCS7_DATA, PR_FALSE, |
| NULL, NULL); |
| } |
| |
| |
| /* |
| * Create an empty PKCS7 encrypted content info. |
| * |
| * "algorithm" specifies the bulk encryption algorithm to use. |
| * |
| * An error results in a return value of NULL and an error set. |
| * (Retrieve specific errors via PORT_GetError()/XP_GetError().) |
| */ |
| SEC_PKCS7ContentInfo * |
| SEC_PKCS7CreateEncryptedData (SECOidTag algorithm, int keysize, |
| SECKEYGetPasswordKey pwfn, void *pwfn_arg) |
| { |
| SEC_PKCS7ContentInfo *cinfo; |
| SECAlgorithmID *algid; |
| SEC_PKCS7EncryptedData *enc_data; |
| SECStatus rv; |
| |
| cinfo = sec_pkcs7_create_content_info (SEC_OID_PKCS7_ENCRYPTED_DATA, |
| PR_FALSE, pwfn, pwfn_arg); |
| if (cinfo == NULL) |
| return NULL; |
| |
| enc_data = cinfo->content.encryptedData; |
| algid = &(enc_data->encContentInfo.contentEncAlg); |
| |
| if (!SEC_PKCS5IsAlgorithmPBEAlgTag(algorithm)) { |
| rv = SECOID_SetAlgorithmID (cinfo->poolp, algid, algorithm, NULL); |
| } else { |
| /* Assume password-based-encryption. |
| * Note: we can't generate pkcs5v2 from this interface. |
| * PK11_CreateBPEAlgorithmID generates pkcs5v2 by accepting |
| * non-PBE oids and assuming that they are pkcs5v2 oids, but |
| * NSS_CMSEncryptedData_Create accepts non-PBE oids as regular |
| * CMS encrypted data, so we can't tell SEC_PKCS7CreateEncryptedtedData |
| * to create pkcs5v2 PBEs */ |
| SECAlgorithmID *pbe_algid; |
| pbe_algid = PK11_CreatePBEAlgorithmID(algorithm, |
| NSS_PBE_DEFAULT_ITERATION_COUNT, |
| NULL); |
| if (pbe_algid == NULL) { |
| rv = SECFailure; |
| } else { |
| rv = SECOID_CopyAlgorithmID (cinfo->poolp, algid, pbe_algid); |
| SECOID_DestroyAlgorithmID (pbe_algid, PR_TRUE); |
| } |
| } |
| |
| if (rv != SECSuccess) { |
| SEC_PKCS7DestroyContentInfo (cinfo); |
| return NULL; |
| } |
| |
| rv = sec_pkcs7_init_encrypted_content_info (&(enc_data->encContentInfo), |
| cinfo->poolp, |
| SEC_OID_PKCS7_DATA, PR_FALSE, |
| algorithm, keysize); |
| if (rv != SECSuccess) { |
| SEC_PKCS7DestroyContentInfo (cinfo); |
| return NULL; |
| } |
| |
| return cinfo; |
| } |
| |