d63d841fb5
Fixes #8923
Found using the openssl cms -resign option.
This uses an alternate path to do the signing which was not adding the required signed attribute
content type. The content type attribute should always exist since it is required is there are
any signed attributes.
As the signing time attribute is always added in code, the content type attribute is also required.
The CMS_si_check_attributes() method adds validity checks for signed and unsigned attributes
e.g. The message digest attribute is a signed attribute that must exist if any signed attributes
exist, it cannot be an unsigned attribute and there must only be one instance containing a single
value.
Reviewed-by: Matt Caswell <matt@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/8944)
(cherry picked from commit 19e512a824)
284 lines
9.4 KiB
C
284 lines
9.4 KiB
C
/*
|
|
* Copyright 2008-2016 The OpenSSL Project Authors. All Rights Reserved.
|
|
*
|
|
* Licensed under the OpenSSL license (the "License"). You may not use
|
|
* this file except in compliance with the License. You can obtain a copy
|
|
* in the file LICENSE in the source distribution or at
|
|
* https://www.openssl.org/source/license.html
|
|
*/
|
|
|
|
#include <openssl/asn1t.h>
|
|
#include <openssl/pem.h>
|
|
#include <openssl/x509v3.h>
|
|
#include <openssl/err.h>
|
|
#include <openssl/cms.h>
|
|
#include "cms_lcl.h"
|
|
#include "internal/nelem.h"
|
|
|
|
/*-
|
|
* Attribute flags.
|
|
* CMS attribute restrictions are discussed in
|
|
* - RFC 5652 Section 11.
|
|
* ESS attribute restrictions are discussed in
|
|
* - RFC 2634 Section 1.3.4 AND
|
|
* - RFC 5035 Section 5.4
|
|
*/
|
|
/* This is a signed attribute */
|
|
#define CMS_ATTR_F_SIGNED 0x01
|
|
/* This is an unsigned attribute */
|
|
#define CMS_ATTR_F_UNSIGNED 0x02
|
|
/* Must be present if there are any other attributes of the same type */
|
|
#define CMS_ATTR_F_REQUIRED_COND 0x10
|
|
/* There can only be one instance of this attribute */
|
|
#define CMS_ATTR_F_ONLY_ONE 0x20
|
|
/* The Attribute's value must have exactly one entry */
|
|
#define CMS_ATTR_F_ONE_ATTR_VALUE 0x40
|
|
|
|
/* Attributes rules for different attributes */
|
|
static const struct {
|
|
int nid; /* The attribute id */
|
|
int flags;
|
|
} cms_attribute_properties[] = {
|
|
/* See RFC Section 11 */
|
|
{ NID_pkcs9_contentType, CMS_ATTR_F_SIGNED
|
|
| CMS_ATTR_F_ONLY_ONE
|
|
| CMS_ATTR_F_ONE_ATTR_VALUE
|
|
| CMS_ATTR_F_REQUIRED_COND },
|
|
{ NID_pkcs9_messageDigest, CMS_ATTR_F_SIGNED
|
|
| CMS_ATTR_F_ONLY_ONE
|
|
| CMS_ATTR_F_ONE_ATTR_VALUE
|
|
| CMS_ATTR_F_REQUIRED_COND },
|
|
{ NID_pkcs9_signingTime, CMS_ATTR_F_SIGNED
|
|
| CMS_ATTR_F_ONLY_ONE
|
|
| CMS_ATTR_F_ONE_ATTR_VALUE },
|
|
{ NID_pkcs9_countersignature, CMS_ATTR_F_UNSIGNED },
|
|
/* ESS */
|
|
{ NID_id_smime_aa_signingCertificate, CMS_ATTR_F_SIGNED
|
|
| CMS_ATTR_F_ONLY_ONE
|
|
| CMS_ATTR_F_ONE_ATTR_VALUE },
|
|
{ NID_id_smime_aa_signingCertificateV2, CMS_ATTR_F_SIGNED
|
|
| CMS_ATTR_F_ONLY_ONE
|
|
| CMS_ATTR_F_ONE_ATTR_VALUE },
|
|
{ NID_id_smime_aa_receiptRequest, CMS_ATTR_F_SIGNED
|
|
| CMS_ATTR_F_ONLY_ONE
|
|
| CMS_ATTR_F_ONE_ATTR_VALUE }
|
|
};
|
|
|
|
/* CMS SignedData Attribute utilities */
|
|
|
|
int CMS_signed_get_attr_count(const CMS_SignerInfo *si)
|
|
{
|
|
return X509at_get_attr_count(si->signedAttrs);
|
|
}
|
|
|
|
int CMS_signed_get_attr_by_NID(const CMS_SignerInfo *si, int nid, int lastpos)
|
|
{
|
|
return X509at_get_attr_by_NID(si->signedAttrs, nid, lastpos);
|
|
}
|
|
|
|
int CMS_signed_get_attr_by_OBJ(const CMS_SignerInfo *si, const ASN1_OBJECT *obj,
|
|
int lastpos)
|
|
{
|
|
return X509at_get_attr_by_OBJ(si->signedAttrs, obj, lastpos);
|
|
}
|
|
|
|
X509_ATTRIBUTE *CMS_signed_get_attr(const CMS_SignerInfo *si, int loc)
|
|
{
|
|
return X509at_get_attr(si->signedAttrs, loc);
|
|
}
|
|
|
|
X509_ATTRIBUTE *CMS_signed_delete_attr(CMS_SignerInfo *si, int loc)
|
|
{
|
|
return X509at_delete_attr(si->signedAttrs, loc);
|
|
}
|
|
|
|
int CMS_signed_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr)
|
|
{
|
|
if (X509at_add1_attr(&si->signedAttrs, attr))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int CMS_signed_add1_attr_by_OBJ(CMS_SignerInfo *si,
|
|
const ASN1_OBJECT *obj, int type,
|
|
const void *bytes, int len)
|
|
{
|
|
if (X509at_add1_attr_by_OBJ(&si->signedAttrs, obj, type, bytes, len))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int CMS_signed_add1_attr_by_NID(CMS_SignerInfo *si,
|
|
int nid, int type, const void *bytes, int len)
|
|
{
|
|
if (X509at_add1_attr_by_NID(&si->signedAttrs, nid, type, bytes, len))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int CMS_signed_add1_attr_by_txt(CMS_SignerInfo *si,
|
|
const char *attrname, int type,
|
|
const void *bytes, int len)
|
|
{
|
|
if (X509at_add1_attr_by_txt(&si->signedAttrs, attrname, type, bytes, len))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
void *CMS_signed_get0_data_by_OBJ(CMS_SignerInfo *si, const ASN1_OBJECT *oid,
|
|
int lastpos, int type)
|
|
{
|
|
return X509at_get0_data_by_OBJ(si->signedAttrs, oid, lastpos, type);
|
|
}
|
|
|
|
int CMS_unsigned_get_attr_count(const CMS_SignerInfo *si)
|
|
{
|
|
return X509at_get_attr_count(si->unsignedAttrs);
|
|
}
|
|
|
|
int CMS_unsigned_get_attr_by_NID(const CMS_SignerInfo *si, int nid,
|
|
int lastpos)
|
|
{
|
|
return X509at_get_attr_by_NID(si->unsignedAttrs, nid, lastpos);
|
|
}
|
|
|
|
int CMS_unsigned_get_attr_by_OBJ(const CMS_SignerInfo *si,
|
|
const ASN1_OBJECT *obj, int lastpos)
|
|
{
|
|
return X509at_get_attr_by_OBJ(si->unsignedAttrs, obj, lastpos);
|
|
}
|
|
|
|
X509_ATTRIBUTE *CMS_unsigned_get_attr(const CMS_SignerInfo *si, int loc)
|
|
{
|
|
return X509at_get_attr(si->unsignedAttrs, loc);
|
|
}
|
|
|
|
X509_ATTRIBUTE *CMS_unsigned_delete_attr(CMS_SignerInfo *si, int loc)
|
|
{
|
|
return X509at_delete_attr(si->unsignedAttrs, loc);
|
|
}
|
|
|
|
int CMS_unsigned_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr)
|
|
{
|
|
if (X509at_add1_attr(&si->unsignedAttrs, attr))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int CMS_unsigned_add1_attr_by_OBJ(CMS_SignerInfo *si,
|
|
const ASN1_OBJECT *obj, int type,
|
|
const void *bytes, int len)
|
|
{
|
|
if (X509at_add1_attr_by_OBJ(&si->unsignedAttrs, obj, type, bytes, len))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int CMS_unsigned_add1_attr_by_NID(CMS_SignerInfo *si,
|
|
int nid, int type,
|
|
const void *bytes, int len)
|
|
{
|
|
if (X509at_add1_attr_by_NID(&si->unsignedAttrs, nid, type, bytes, len))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int CMS_unsigned_add1_attr_by_txt(CMS_SignerInfo *si,
|
|
const char *attrname, int type,
|
|
const void *bytes, int len)
|
|
{
|
|
if (X509at_add1_attr_by_txt(&si->unsignedAttrs, attrname,
|
|
type, bytes, len))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
void *CMS_unsigned_get0_data_by_OBJ(CMS_SignerInfo *si, ASN1_OBJECT *oid,
|
|
int lastpos, int type)
|
|
{
|
|
return X509at_get0_data_by_OBJ(si->unsignedAttrs, oid, lastpos, type);
|
|
}
|
|
|
|
/*
|
|
* Retrieve an attribute by nid from a stack of attributes starting at index
|
|
* *lastpos + 1.
|
|
* Returns the attribute or NULL if there is no attribute.
|
|
* If an attribute was found *lastpos returns the index of the found attribute.
|
|
*/
|
|
static X509_ATTRIBUTE *cms_attrib_get(int nid,
|
|
const STACK_OF(X509_ATTRIBUTE) *attrs,
|
|
int *lastpos)
|
|
{
|
|
X509_ATTRIBUTE *at;
|
|
int loc;
|
|
|
|
loc = X509at_get_attr_by_NID(attrs, nid, *lastpos);
|
|
if (loc < 0)
|
|
return NULL;
|
|
|
|
at = X509at_get_attr(attrs, loc);
|
|
*lastpos = loc;
|
|
return at;
|
|
}
|
|
|
|
static int cms_check_attribute(int nid, int flags, int type,
|
|
const STACK_OF(X509_ATTRIBUTE) *attrs,
|
|
int have_attrs)
|
|
{
|
|
int lastpos = -1;
|
|
X509_ATTRIBUTE *at = cms_attrib_get(nid, attrs, &lastpos);
|
|
|
|
if (at != NULL) {
|
|
int count = X509_ATTRIBUTE_count(at);
|
|
|
|
/* Is this attribute allowed? */
|
|
if (((flags & type) == 0)
|
|
/* check if multiple attributes of the same type are allowed */
|
|
|| (((flags & CMS_ATTR_F_ONLY_ONE) != 0)
|
|
&& cms_attrib_get(nid, attrs, &lastpos) != NULL)
|
|
/* Check if attribute should have exactly one value in its set */
|
|
|| (((flags & CMS_ATTR_F_ONE_ATTR_VALUE) != 0)
|
|
&& count != 1)
|
|
/* There should be at least one value */
|
|
|| count == 0)
|
|
return 0;
|
|
} else {
|
|
/* fail if a required attribute is missing */
|
|
if (have_attrs
|
|
&& ((flags & CMS_ATTR_F_REQUIRED_COND) != 0)
|
|
&& (flags & type) != 0)
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Check that the signerinfo attributes obey the attribute rules which includes
|
|
* the following checks
|
|
* - If any signed attributes exist then there must be a Content Type
|
|
* and Message Digest attribute in the signed attributes.
|
|
* - The countersignature attribute is an optional unsigned attribute only.
|
|
* - Content Type, Message Digest, and Signing time attributes are signed
|
|
* attributes. Only one instance of each is allowed, with each of these
|
|
* attributes containing a single attribute value in its set.
|
|
*/
|
|
int CMS_si_check_attributes(const CMS_SignerInfo *si)
|
|
{
|
|
int i;
|
|
int have_signed_attrs = (CMS_signed_get_attr_count(si) > 0);
|
|
int have_unsigned_attrs = (CMS_unsigned_get_attr_count(si) > 0);
|
|
|
|
for (i = 0; i < (int)OSSL_NELEM(cms_attribute_properties); ++i) {
|
|
int nid = cms_attribute_properties[i].nid;
|
|
int flags = cms_attribute_properties[i].flags;
|
|
|
|
if (!cms_check_attribute(nid, flags, CMS_ATTR_F_SIGNED,
|
|
si->signedAttrs, have_signed_attrs)
|
|
|| !cms_check_attribute(nid, flags, CMS_ATTR_F_UNSIGNED,
|
|
si->unsignedAttrs, have_unsigned_attrs)) {
|
|
CMSerr(CMS_F_CMS_SI_CHECK_ATTRIBUTES, CMS_R_ATTRIBUTE_ERROR);
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|