#include "CMSEncoder.h"
#include "CMSPrivate.h"
#include "CMSUtils.h"
-#include <CoreServices/../Frameworks/CarbonCore.framework/Headers/MacErrors.h>
+#include <Security/SecBase.h>
#include <Security/SecCmsEncoder.h>
#include <Security/SecCmsEnvelopedData.h>
#include <Security/SecCmsMessage.h>
{
unsigned char **digits = NULL; /* array of char * from encodeNumber */
unsigned *numDigits = NULL; /* array of unsigned from encodeNumber */
- unsigned digit;
+ CFIndex digit;
unsigned numDigitBytes; /* total #of output chars */
unsigned char firstByte;
unsigned char *outP;
- unsigned numsToProcess;
+ CFIndex numsToProcess;
CFStringRef oidStr = NULL;
CFArrayRef argvRef = NULL;
- int num, argc, result = 1;
+ int num, result = 1;
+ CFIndex argc;
/* parse input string into array of substrings */
if (!inStr || !outOid || !outLen) goto cleanExit;
CSSM_OID *outOid)
{
if (!inRef || !outOid)
- return paramErr;
+ return errSecParam;
unsigned char *oidData = NULL;
unsigned int oidLen = 0;
CFIndex max = CFStringGetLength(inStr) * 3;
char buf[max];
if (!CFStringGetCString(inStr, buf, max-1, kCFStringEncodingASCII))
- return paramErr;
+ return errSecParam;
if(encodeOid((unsigned char *)buf, &oidData, &oidLen) != 0)
- return paramErr;
+ return errSecParam;
}
else if (CFGetTypeID(inRef) == CFDataGetTypeID()) {
// CFDataRef: OID representation is in binary DER format
}
else {
// Not in a format we understand
- return paramErr;
+ return errSecParam;
}
outOid->Length = oidLen;
outOid->Data = (uint8 *)oidData;
if(ortn) {
return cmsRtnToOSStatus(ortn);
}
- return noErr;
+ return errSecSuccess;
}
/*
}
cmsEncoder->cmsMsg = SecCmsMessageCreate(NULL);
if(cmsEncoder->cmsMsg == NULL) {
- return internalComponentErr;
+ return errSecInternalComponent;
}
signedData = SecCmsSignedDataCreate(cmsEncoder->cmsMsg);
if(signedData == NULL) {
- return internalComponentErr;
+ return errSecInternalComponent;
}
contentInfo = SecCmsMessageGetContentInfo(cmsEncoder->cmsMsg);
ortn = SecCmsContentInfoSetContentSignedData(cmsEncoder->cmsMsg, contentInfo,
}
signerInfo = SecCmsSignerInfoCreate(cmsEncoder->cmsMsg, ourId, SEC_OID_SHA1);
if (signerInfo == NULL) {
- ortn = internalComponentErr;
+ ortn = errSecInternalComponent;
break;
}
}
cmsEncoder->cmsMsg = SecCmsMessageCreate(NULL);
if(cmsEncoder->cmsMsg == NULL) {
- return internalComponentErr;
+ return errSecInternalComponent;
}
envelopedData = SecCmsEnvelopedDataCreate(cmsEncoder->cmsMsg,
algorithmTag, keySize);
if(envelopedData == NULL) {
- return internalComponentErr;
+ return errSecInternalComponent;
}
contentInfo = SecCmsMessageGetContentInfo(cmsEncoder->cmsMsg);
ortn = SecCmsContentInfoSetContentEnvelopedData(cmsEncoder->cmsMsg,
return ortn;
}
}
- return noErr;
+ return errSecSuccess;
}
/*
}
else {
dprintf("CMSEncoderUpdateContent: nothing to do\n");
- return paramErr;
+ return errSecParam;
}
- OSStatus ortn = noErr;
+ OSStatus ortn = errSecSuccess;
switch(cmsEncoder->op) {
case EO_Sign:
}
if(decodedInfo.content.Data == NULL) {
dprintf("***Error decoding contentInfo: no content\n");
- return internalComponentErr;
+ return errSecInternalComponent;
}
*content = decodedInfo.content;
- return noErr;
+ return errSecSuccess;
}
#pragma mark --- Start of Public API ---
cmsEncoder = (CMSEncoderRef)_CFRuntimeCreateInstance(NULL, CMSEncoderGetTypeID(),
extra, NULL);
if(cmsEncoder == NULL) {
- return memFullErr;
+ return errSecAllocate;
}
cmsEncoder->encState = ES_Init;
cmsEncoder->chainMode = kCMSCertificateChain;
*cmsEncoderOut = cmsEncoder;
- return noErr;
+ return errSecSuccess;
}
#pragma mark --- Getters & Setters ---
CFTypeRef signerOrArray)
{
if(cmsEncoder == NULL) {
- return paramErr;
+ return errSecParam;
}
if(cmsEncoder->encState != ES_Init) {
- return paramErr;
+ return errSecParam;
}
return cmsAppendToArray(signerOrArray, &cmsEncoder->signers, SecIdentityGetTypeID());
}
CFArrayRef *signers)
{
if((cmsEncoder == NULL) || (signers == NULL)) {
- return paramErr;
+ return errSecParam;
}
if(cmsEncoder->signers != NULL) {
CFRetain(cmsEncoder->signers);
}
*signers = cmsEncoder->signers;
- return noErr;
+ return errSecSuccess;
}
/*
CFTypeRef recipientOrArray)
{
if(cmsEncoder == NULL) {
- return paramErr;
+ return errSecParam;
}
if(cmsEncoder->encState != ES_Init) {
- return paramErr;
+ return errSecParam;
}
return cmsAppendToArray(recipientOrArray, &cmsEncoder->recipients,
SecCertificateGetTypeID());
CFArrayRef *recipients)
{
if((cmsEncoder == NULL) || (recipients == NULL)) {
- return paramErr;
+ return errSecParam;
}
if(cmsEncoder->recipients != NULL) {
CFRetain(cmsEncoder->recipients);
}
*recipients = cmsEncoder->recipients;
- return noErr;
+ return errSecSuccess;
}
/*
CFTypeRef certOrArray)
{
if(cmsEncoder == NULL) {
- return paramErr;
+ return errSecParam;
}
if(cmsEncoder->encState != ES_Init) {
- return paramErr;
+ return errSecParam;
}
return cmsAppendToArray(certOrArray, &cmsEncoder->otherCerts,
SecCertificateGetTypeID());
CFArrayRef *certs) /* RETURNED */
{
if((cmsEncoder == NULL) || (certs == NULL)) {
- return paramErr;
+ return errSecParam;
}
if(cmsEncoder->otherCerts != NULL) {
CFRetain(cmsEncoder->otherCerts);
}
*certs = cmsEncoder->otherCerts;
- return noErr;
+ return errSecSuccess;
}
OSStatus CMSEncoderSetHasDetachedContent(
Boolean detachedContent)
{
if(cmsEncoder == NULL) {
- return paramErr;
+ return errSecParam;
}
if(cmsEncoder->encState != ES_Init) {
- return paramErr;
+ return errSecParam;
}
cmsEncoder->detachedContent = detachedContent;
- return noErr;
+ return errSecSuccess;
}
OSStatus CMSEncoderGetHasDetachedContent(
Boolean *detachedContent) /* RETURNED */
{
if((cmsEncoder == NULL) || (detachedContent == NULL)) {
- return paramErr;
+ return errSecParam;
}
*detachedContent = cmsEncoder->detachedContent;
- return noErr;
+ return errSecSuccess;
}
/*
const CSSM_OID *eContentType)
{
if((cmsEncoder == NULL) || (eContentType == NULL)) {
- return paramErr;
+ return errSecParam;
}
if(cmsEncoder->encState != ES_Init) {
- return paramErr;
+ return errSecParam;
}
CSSM_OID *ecOid = &cmsEncoder->eContentType;
free(ecOid->Data);
}
cmsCopyCmsData(eContentType, ecOid);
- return noErr;
+ return errSecSuccess;
}
OSStatus CMSEncoderSetEncapsulatedContentTypeOID(
// convert eContentTypeOID to a CSSM_OID
CSSM_OID contentType = { 0, NULL };
if (!eContentTypeOID || convertOid(eContentTypeOID, &contentType) != 0)
- return paramErr;
+ return errSecParam;
OSStatus result = CMSEncoderSetEncapsulatedContentType(cmsEncoder, &contentType);
if (contentType.Data)
free(contentType.Data);
CFDataRef *eContentType)
{
if((cmsEncoder == NULL) || (eContentType == NULL)) {
- return paramErr;
+ return errSecParam;
}
CSSM_OID *ecOid = &cmsEncoder->eContentType;
else {
*eContentType = CFDataCreate(NULL, ecOid->Data, ecOid->Length);
}
- return noErr;
+ return errSecSuccess;
}
/*
CMSSignedAttributes signedAttributes)
{
if(cmsEncoder == NULL) {
- return paramErr;
+ return errSecParam;
}
if(cmsEncoder->encState != ES_Init) {
- return paramErr;
+ return errSecParam;
}
cmsEncoder->signedAttributes = signedAttributes;
- return noErr;
+ return errSecSuccess;
}
/*
CFAbsoluteTime time)
{
if(cmsEncoder == NULL) {
- return paramErr;
+ return errSecParam;
}
if(cmsEncoder->encState != ES_Init) {
- return paramErr;
+ return errSecParam;
}
cmsEncoder->signingTime = time;
- return noErr;
+ return errSecSuccess;
}
CMSCertificateChainMode chainMode)
{
if(cmsEncoder == NULL) {
- return paramErr;
+ return errSecParam;
}
if(cmsEncoder->encState != ES_Init) {
- return paramErr;
+ return errSecParam;
}
switch(chainMode) {
case kCMSCertificateNone:
case kCMSCertificateChainWithRoot:
break;
default:
- return paramErr;
+ return errSecParam;
}
cmsEncoder->chainMode = chainMode;
- return noErr;
+ return errSecSuccess;
}
OSStatus CMSEncoderGetCertificateChainMode(
CMSCertificateChainMode *chainModeOut)
{
if(cmsEncoder == NULL) {
- return paramErr;
+ return errSecParam;
}
*chainModeOut = cmsEncoder->chainMode;
- return noErr;
+ return errSecSuccess;
}
void
size_t contentLen)
{
if(cmsEncoder == NULL) {
- return paramErr;
+ return errSecParam;
}
- OSStatus ortn = noErr;
+ OSStatus ortn = errSecSuccess;
switch(cmsEncoder->encState) {
case ES_Init:
/*
case ES_Final:
/* Too late for another update */
- return paramErr;
+ return errSecParam;
default:
- return internalComponentErr;
+ return errSecInternalComponent;
}
/* FIXME - CFIndex same size as size_t on 64bit? */
CFDataRef *encodedContent)
{
if((cmsEncoder == NULL) || (encodedContent == NULL)) {
- return paramErr;
+ return errSecParam;
}
OSStatus ortn;
break;
case ES_Final:
/* already been called */
- return paramErr;
+ return errSecParam;
case ES_Msg:
case ES_Init:
/*
if((cmsEncoder->signers != NULL) ||
(cmsEncoder->recipients != NULL) ||
(cmsEncoder->otherCerts == NULL)) {
- return paramErr;
+ return errSecParam;
}
/* Set up for certs only */
if((cmsEncoder->encoderOut.Data == NULL) && !cmsEncoder->customCoder) {
/* not sure how this could happen... */
dprintf("Successful encode, but no data\n");
- return internalComponentErr;
+ return errSecInternalComponent;
}
if(cmsEncoder->customCoder) {
/* we're done */
*encodedContent = NULL;
- return noErr;
+ return errSecSuccess;
}
/* in two out of three cases, we're done */
case EO_Encrypt:
*encodedContent = CFDataCreate(NULL, (const UInt8 *)cmsEncoder->encoderOut.Data,
cmsEncoder->encoderOut.Length);
- return noErr;
+ return errSecSuccess;
case EO_SignEncrypt:
/* proceed, more work to do */
break;
CFDataRef *encodedContent) /* RETURNED */
{
if((signers == NULL) && (recipients == NULL)) {
- return paramErr;
+ return errSecParam;
}
if(encodedContent == NULL) {
- return paramErr;
+ return errSecParam;
}
CMSEncoderRef cmsEncoder;
// convert eContentTypeOID to a CSSM_OID
CSSM_OID contentType = { 0, NULL };
if (eContentTypeOID && convertOid(eContentTypeOID, &contentType) != 0)
- return paramErr;
+ return errSecParam;
const CSSM_OID *contentTypePtr = (eContentTypeOID) ? &contentType : NULL;
OSStatus result = CMSEncode(signers, recipients, contentTypePtr,
detachedContent, signedAttributes,
SecCmsMessageRef *cmsMessage) /* RETURNED */
{
if((cmsEncoder == NULL) || (cmsMessage == NULL)) {
- return paramErr;
+ return errSecParam;
}
if(cmsEncoder->cmsMsg != NULL) {
ASSERT(cmsEncoder->encState != ES_Init);
*cmsMessage = cmsEncoder->cmsMsg;
- return noErr;
+ return errSecSuccess;
}
OSStatus ortn = cmsSetupCmsMsg(cmsEncoder);
/* Don't set up encoder yet; caller might do that via CMSEncoderSetEncoder */
cmsEncoder->encState = ES_Msg;
- return noErr;
+ return errSecSuccess;
}
/*
SecCmsEncoderRef encoder)
{
if((cmsEncoder == NULL) || (encoder == NULL)) {
- return paramErr;
+ return errSecParam;
}
OSStatus ortn;
cmsEncoder->encoder = encoder;
cmsEncoder->encState = ES_Updating;
cmsEncoder->customCoder = true; /* we won't see data */
- return noErr;
+ return errSecSuccess;
default:
/* no can do, too late */
- return paramErr;
+ return errSecParam;
}
}
SecCmsEncoderRef *encoder) /* RETURNED */
{
if((cmsEncoder == NULL) || (encoder == NULL)) {
- return paramErr;
+ return errSecParam;
}
/* any state, whether we have an encoder or not is OK */
*encoder = cmsEncoder->encoder;
- return noErr;
+ return errSecSuccess;
}
#include <AssertMacros.h>
* present. This timestamp is an authenticated timestamp provided by
* a timestamping authority.
*
- * Returns paramErr if the CMS message was not signed or if signerIndex
+ * Returns errSecParam if the CMS message was not signed or if signerIndex
* is greater than the number of signers of the message minus one.
*
* This cannot be called until after CMSEncoderCopyEncodedContent() is called.
size_t signerIndex, /* usually 0 */
CFAbsoluteTime *timestamp) /* RETURNED */
{
- OSStatus status = paramErr;
+ OSStatus status = errSecParam;
SecCmsMessageRef cmsg;
SecCmsSignedDataRef signedData = NULL;
int numContentInfos = 0;
projects / apple / security.git / blobdiff