{

ASN1_OBJECT *algorithm;

ASN1_NULL *parameters;

{

AlgorithmIdentifier *algorithm;

ASN1_OCTET_STRING *digest;

{

int type;

union

{

ASN1_STRING *variant;

ASN1_BMPSTRING *unicode;

ASN1_IA5STRING *ascii;

} d;

{

ASN1_OCTET_STRING *class_id;

ASN1_OCTET_STRING *data;

{

int type;

union

{

ASN1_IA5STRING *url;

SpcSerializedObject *moniker;

SpcString *file;

} d;

{

SpcString *description;

SpcLink *url;

{

ASN1_BIT_STRING *flags;

SpcLink *file;

{

ASN1_OBJECT *type;

SpcPeImageData *value;

{

SpcAttributeTypeAndOptionalValue *data;

DigestInfo *digest;

{

ASN1_OBJECT *type;

ASN1_OCTET_STRING *signature;

{

ASN1_OBJECT *type;

SpcTimeStampRequestBlob *blob;

{

bool t_success;

t_success = true;

uint32_t t_length;

t_length = 0;

if (t_success)

{

t_length = p_i2d(p_object, nil);

if (t_length == 0)

t_success = MCDeployThrowOpenSSL(kMCDeployErrorBadSignature);

}

uint8_t *t_data;

t_data = nil;

if (t_success)

{

t_data = (uint8_t *)OPENSSL_malloc(t_length);

if (t_data == nil)

t_success = MCDeployThrowOpenSSL(kMCDeployErrorNoMemory);

}

if (t_success)

{

p_i2d(p_object, &t_data);

r_data = t_data - t_length;

r_length = t_length;

}

else

{

if (t_data != nil)

OPENSSL_free(t_data);

}

return t_success;

{

// SN-2014-01-10: The certificate filename can be in unicode.

// As a char* is required, the conversion must be done.

// On Mac, UTF8 suits the filesystem encoding requirements

// On Windows, BIO_new_file expects a UFT-8 path

// On Linux, a SysString is used

#ifdef _LINUX

MCAutoStringRefAsSysString t_certificate;

#else

MCAutoStringRefAsUTF8String t_certificate;

#endif

t_certificate . Lock(p_certificate);

BIO *t_file;

t_file = BIO_new_file(*t_certificate, "rb");

if (t_file == nil)

return MCDeployThrowOpenSSL(kMCDeployErrorNoCertificate);

PKCS7 *t_cert;

t_cert = d2i_PKCS7_bio(t_file, nil);

// If we failed to read the cert as binary, try as base64 encoded (VeriSign seems

// to provide such certs like that).

if (t_cert == nil)

{

BIO_seek(t_file, 0);

t_file = BIO_push(BIO_new(BIO_f_base64()), t_file);

t_cert = d2i_PKCS7_bio(t_file, nil);

}

BIO_free_all(t_file);

if (t_cert == nil)

return MCDeployThrowOpenSSL(kMCDeployErrorBadCertificate);

r_chain = t_cert;

return true;

{

bool t_success;

t_success = true;

SpcString *t_string;

t_string = nil;

if (t_success)

{

t_string = SpcString_new();

if (t_string == nil)

t_success = MCDeployThrowOpenSSL(kMCDeployErrorNoMemory);

}

ASN1_STRING *t_value;

t_value = nil;

if (t_success)

{

if (!ASN1_mbstring_copy(&t_value, (const unsigned char *)p_value, strlen(p_value), MBSTRING_UTF8, p_is_ascii ? B_ASN1_IA5STRING : B_ASN1_BMPSTRING))

t_success = MCDeployThrowOpenSSL(kMCDeployErrorBadString);

}

if (t_success)

{

t_string -> type = p_is_ascii ? 1 : 0;

t_string -> d . variant = t_value;

r_string = t_string;

}

else

{

if (t_string != nil)

SpcString_free(t_string);

if (t_value != nil)

ASN1_STRING_free(t_value);

}

return t_success;

{

bool t_success;

t_success = true;

// Read the hash from the bio

uint8_t t_hash_data[EVP_MAX_MD_SIZE];

uint32_t t_hash_length;

if (t_success)

{

t_hash_length = BIO_gets(p_hash, (char *)t_hash_data, EVP_MAX_MD_SIZE);

if (t_hash_length == 0)

t_success = MCDeployThrowOpenSSL(kMCDeployErrorBadHash);

}

// Construct all the ASN.1 objects we need.

SpcIndirectDataContent *t_content;

SpcAttributeTypeAndOptionalValue *t_data;

DigestInfo *t_message_digest;

AlgorithmIdentifier *t_digest_algorithm;

SpcPeImageData *t_image_data;

SpcLink *t_image_data_file;

t_data = nil;

t_message_digest = nil;

t_digest_algorithm = nil;

t_image_data = nil;

t_content = nil;

t_image_data_file = nil;

if (t_success)

{

t_content = SpcIndirectDataContent_new();

t_data = SpcAttributeTypeAndOptionalValue_new();

t_message_digest = DigestInfo_new();

t_digest_algorithm = AlgorithmIdentifier_new();

t_image_data = SpcPeImageData_new();

t_image_data_file = SpcLink_new();

if (t_content == nil || t_data == nil || t_message_digest == nil || t_digest_algorithm == nil ||

t_image_data == nil || t_image_data_file == nil)

t_success = MCDeployThrow(kMCDeployErrorNoMemory);

}

if (t_success)

t_success = MCDeployBuildSpcString("<<<Obsolete>>>", false, t_image_data_file -> d . file);

if (t_success)

{

t_image_data -> flags = ASN1_BIT_STRING_new();

if (t_image_data -> flags == nil)

t_success = MCDeployThrowOpenSSL(kMCDeployErrorNoMemory);

}

if (t_success)

{

t_message_digest -> digest = ASN1_OCTET_STRING_new();

if (t_message_digest -> digest == nil ||

!ASN1_OCTET_STRING_set(t_message_digest -> digest, t_hash_data, t_hash_length))

t_success = MCDeployThrowOpenSSL(kMCDeployErrorNoMemory);

}

if (t_success)

{

t_digest_algorithm -> parameters = ASN1_NULL_new();

if (t_digest_algorithm -> parameters == nil)

t_success = MCDeployThrowOpenSSL(kMCDeployErrorNoMemory);

}

if (t_success)

{

t_content -> data = t_data;

t_content -> digest = t_message_digest;

t_data -> type = OBJ_txt2obj(SPC_PE_IMAGE_DATA_OBJID, 0);

t_data -> value = t_image_data;

t_message_digest -> algorithm = t_digest_algorithm;

t_digest_algorithm -> algorithm = OBJ_nid2obj(NID_sha1); // NID_md5

t_image_data_file -> type = 2;

t_image_data -> file = t_image_data_file;

r_content = t_content;

}

else

{

if (t_image_data_file != nil)

SpcLink_free(t_image_data_file);

if (t_image_data != nil)

SpcPeImageData_free(t_image_data);

if (t_digest_algorithm != nil)

AlgorithmIdentifier_free(t_digest_algorithm);

if (t_message_digest != nil)

DigestInfo_free(t_message_digest);

if (t_data != nil)

SpcAttributeTypeAndOptionalValue_free(t_data);

if (t_content != nil)

SpcIndirectDataContent_free(t_content);

}

return t_success;

{

// First get the length of the input file

uint32_t t_length;

if (!MCDeployFileMeasure(p_input, t_length))

return false;

// Now check the first two bytes - these should be MZ

char t_buffer[4];

if (!MCDeployFileReadAt(p_input, t_buffer, 2, 0) ||

!MCMemoryEqual(t_buffer, "MZ", 2))

return MCDeployThrow(kMCDeployErrorWindowsBadDOSSignature);

// Now read in the offset to the pe header - this resides at

// byte offset 60 (member e_lfanew in IMAGE_DOS_HEADER).

uint32_t t_offset;

if (t_length < 64 ||

!MCDeployFileReadAt(p_input, &t_offset, 4, 60))

return MCDeployThrow(kMCDeployErrorWindowsBadDOSHeader);

// Swap from non-network to host byte order

MCDeployByteSwap32(false, t_offset);

// Check the NT header is big enough - here 160 is the minimum size of the

// NT header we need. This is:

// 4 byte signature

// 20 byte file header

// 28 byte standard header

// 68 byte optional header

// 40 byte data directory (i.e. up to and including SECURITY entry).

if (t_length < t_offset + 160)

return MCDeployThrow(kMCDeployErrorWindowsNoNTHeader);

// Now make sure the NT Signature is correct and read in the existing cert

// fields. Note that the offset here is that of the 5th data directory entry

// (4 + 20 + 28 + 64 + 5 * 8).

uint32_t t_cert_section[2];

if (!MCDeployFileReadAt(p_input, t_buffer, 4, t_offset) ||

!MCMemoryEqual(t_buffer, "PE\0\0", 4) ||

!MCDeployFileReadAt(p_input, t_cert_section, 2 * sizeof(uint32_t), t_offset + 152))

return MCDeployThrow(kMCDeployErrorWindowsBadNTSignature);

MCDeployByteSwap32(false, t_cert_section[0]);

MCDeployByteSwap32(false, t_cert_section[1]);

// Make sure that if there is an existing certicate, that it is at the end

// of the file.

if (t_cert_section[0] != 0 && t_cert_section[0] + t_cert_section[1] != t_length)

return MCDeployThrow(kMCDeployErrorWindowsBadSecuritySection);

if (t_cert_section[0] != 0)

r_cert_offset = t_cert_section[0];

else

r_cert_offset = t_length;

r_pe_offset = t_offset;

return true;

{

bool t_success;

t_success = true;

if (!MCDeployFileSeekSet(p_input, p_offset))

return MCDeployThrow(kMCDeployErrorBadRead);

while(p_amount > 0)

{

char t_buffer[4096];

int t_size;

t_size = MCU_min(4096U, p_amount);

if (!MCDeployFileRead(p_input, t_buffer, t_size))

return MCDeployThrow(kMCDeployErrorBadRead);

if (BIO_write(p_output, t_buffer, t_size) != t_size)

return MCDeployThrowOpenSSL(kMCDeployErrorBadWrite);

p_amount -= t_size;

}

return true;

{

bool t_success;

t_success = true;

// First construct a hash BIO and chain it to the output bio.

BIO *t_hash;

t_hash = nil;

if (t_success)

{

t_hash = BIO_new(BIO_f_md());

if (t_hash == nil)

t_success = MCDeployThrowOpenSSL(kMCDeployErrorNoMemory);

BIO_set_md(t_hash, EVP_sha1()); // EVP_md5

BIO_push(t_hash, p_output);

}

// Now we generate the new output file, hashing the appropriate portions of

// the input executable as we go.

// The first part of the output file is everything up to the start of the

// 'CheckSum' field of the IMAGE_OPTIONAL_HEADER32 structure. This is at

// offset 88 in said structure. This part is part of the hash.

if (t_success)

t_success = MCDeploySignCopyFileAt(t_hash, p_input, 0, p_pe_offset + 88);

// Next we write out an empty (0) CheckSum field - this section is not

// hashed.

if (t_success)

{

uint32_t t_checksum;

t_checksum = 0;

if (BIO_write(p_output, &t_checksum, sizeof(t_checksum)) != sizeof(uint32_t))

t_success = MCDeployThrowOpenSSL(kMCDeployErrorBadWrite);

}

// Next is the section of the header after the CheckSum field and up to

// the 'Security' data directory entry. This entry is at offset 152.

if (t_success)

t_success = MCDeploySignCopyFileAt(t_hash, p_input, p_pe_offset + 92, 60);

// Now write out the (current) value of the Security data directory entry,

// but not into the hash.

if (t_success)

t_success = MCDeploySignCopyFileAt(p_output, p_input, p_pe_offset + 152, 8);

// After the Security data directory, everything up to the cert offset is

// hashed.

if (t_success)

t_success = MCDeploySignCopyFileAt(t_hash, p_input, p_pe_offset + 160, p_cert_offset - (p_pe_offset + 160));

// Finally we round the output up to the nearest 8 bytes.

if (t_success && (p_cert_offset % 8 != 0))

{

uint8_t t_pad[8];

MCMemoryClear(t_pad, 8);

int t_pad_length;

t_pad_length = 8 - (p_cert_offset % 8);

if (BIO_write(t_hash, t_pad, t_pad_length) != t_pad_length)

t_success = MCDeployThrowOpenSSL(kMCDeployErrorBadWrite);

}

// If we have failed, make sure we free the hash BIO, otherwise we return

// it.

if (t_success)

r_hash = t_hash;

else

BIO_free(t_hash);

return t_success;

{

bool t_success;

t_success = true;

SpcSpOpusInfo *t_opus;

t_opus = nil;

if (t_success)

{

t_opus = SpcSpOpusInfo_new();

if (t_opus == nil)

t_success = MCDeployThrowOpenSSL(kMCDeployErrorNoMemory);

}

if (t_success && p_params . description != nil)

{

MCAutoStringRefAsUTF8String t_utf8_string;

t_success = t_utf8_string . Lock(p_params . description)

&& MCDeployBuildSpcString(*t_utf8_string, false, t_opus -> description);

}

if (t_success && p_params . url != nil)

{

t_opus -> url = SpcLink_new();

if (t_opus -> url != nil)

{

if (ASN1_mbstring_copy(&t_opus -> url -> d . url, MCStringGetNativeCharPtr(p_params.url), MCStringGetLength(p_params.url), MBSTRING_UTF8, B_ASN1_IA5STRING))

t_opus -> url -> type = 0;

else

t_success = MCDeployThrowOpenSSL(kMCDeployErrorBadString);

}

else

t_success = MCDeployThrowOpenSSL(kMCDeployErrorNoMemory);

}

uint8_t *t_opus_data;

uint32_t t_opus_length;

t_opus_data = nil;

t_opus_length = 0;

if (t_success)

t_success = i2d(i2d_SpcSpOpusInfo, t_opus, t_opus_data, t_opus_length);

ASN1_STRING *t_opus_string;

t_opus_string = nil;

if (t_success)

{

t_opus_string = ASN1_STRING_new();

if (t_opus_string == nil ||

!ASN1_STRING_set(t_opus_string, t_opus_data, t_opus_length))

t_success = MCDeployThrow(kMCDeployErrorNoMemory);

}

if (t_success)

{

if (!PKCS7_add_signed_attribute(p_sign_info, OBJ_txt2nid(SPC_SP_OPUS_INFO_OBJID), V_ASN1_SEQUENCE, t_opus_string))

t_success = MCDeployThrowOpenSSL(kMCDeployErrorBadSignature);

}

// Note that this is not owned by the sig if we failed.

if (!t_success)

{

if (t_opus_string != nil)

ASN1_STRING_free(t_opus_string);

}

if (t_opus_data != nil)

OPENSSL_free(t_opus_data);

if (t_opus != nil)

SpcSpOpusInfo_free(t_opus);

return t_success;

{

bool t_success;

t_success = true;

// Fetch the signatures 'signer_info' structure

PKCS7_SIGNER_INFO *t_signer_info;

t_signer_info = sk_PKCS7_SIGNER_INFO_value(p_signature -> d . sign -> signer_info, 0);

// Build a request to send to the time-stamp authority. If there is a 'blob'

// field in this request, then we must reset the signature field before freeing

// it as that is borrowed from elsewhere.

SpcTimeStampRequest *t_request;

t_request = nil;

if (t_success)

{

t_request = SpcTimeStampRequest_new();

if (t_request != nil)

{

t_request -> type = OBJ_txt2obj(SPC_TIME_STAMP_REQUEST_OBJID, 1);

t_request -> blob = SpcTimeStampRequestBlob_new();

if (t_request -> blob != nil)

{

t_request -> blob -> type = OBJ_nid2obj(NID_pkcs7_data);

t_request -> blob -> signature = t_signer_info -> enc_digest;

}

else

t_success = MCDeployThrow(kMCDeployErrorNoMemory);

}

else

t_success = MCDeployThrow(kMCDeployErrorNoMemory);

}

// Convert the request to the binary encoding

uint8_t *t_request_data;

uint32_t t_request_length;

t_request_data = nil;

t_request_length = 0;

if (t_success)

t_success = i2d(i2d_SpcTimeStampRequest, t_request, t_request_data, t_request_length);

// Convert the request to base64

MCAutoDataRef t_req_dataref;

MCAutoStringRef t_req_base64;

/* UNCHECKED */ MCDataCreateWithBytes(t_request_data, t_request_length, &t_req_dataref);

MCU_base64encode(*t_req_dataref, &t_req_base64);

// Request the timestamp from the tsa

if (t_success)

{

// Set the HTTP headers appropriately to make sure no unpleasant caching goes on.

MCValueAssign(MChttpheaders, MCSTR("Content-Type: application/octet-stream\nAccept: application/octet-stream\nUser-Agent: Transport\nCache-Control: no-cache"));

// Use libURL to do the post - we attempt this 5 times with increasing sleep

// periods. This is because it looks like the timestamping service is a little

// unreliable (well, VeriSign's timestamping service anyway!).

uint32_t t_retry_count, t_retry_interval;

t_retry_count = 5;

t_retry_interval = 50;

bool t_failed;

t_failed = true;

while(t_retry_count > 0)

{

MCParameter t_data, t_url;

t_data . setvalueref_argument(*t_req_base64);

t_data . setnext(&t_url);

t_url . setvalueref_argument(p_params . timestamper);

extern MCExecContext *MCECptr;

if (MCECptr->GetObject() -> message(MCM_post_url, &t_data, False, True) == ES_NORMAL &&

MCresult -> isempty())

{

t_failed = false;

break;

}

// Sleep for retry_interval millisecs.

MCS_sleep(t_retry_interval / 1000.0);

t_retry_count -= 1;

t_retry_interval *= 2;

}

if (t_failed)

t_success = MCDeployThrow(kMCDeployErrorTimestampFailed);

}

// Now convert the reply to binary.

MCAutoValueRef t_result_value;

MCAutoStringRef t_result_base64;

MCAutoDataRef t_result_data;

extern MCExecContext *MCECptr;

if (t_success)

{

MCurlresult -> copyasvalueref(&t_result_value);

t_success = MCECptr->ConvertToString(*t_result_value, &t_result_base64);

}

if (t_success)

MCU_base64decode(*t_result_base64, &t_result_data);

// Decode the PKCS7 structure

PKCS7 *t_counter_sig;

t_counter_sig = nil;

if (t_success)

{

const unsigned char *t_data;

t_data = (const unsigned char *)MCDataGetBytePtr(*t_result_data);

int t_length;

t_length = MCDataGetLength(*t_result_data);

t_counter_sig = d2i_PKCS7(&t_counter_sig, &t_data, t_length);

if (t_counter_sig == nil)

t_success = MCDeployThrow(kMCDeployErrorBadTimestamp);

}

// Add the certificates we need to our signature

if (t_success)

for(int32_t i = sk_X509_num(t_counter_sig -> d . sign -> cert) - 1; i >= 0 && t_success; i--)

if (!PKCS7_add_certificate(p_signature, sk_X509_value(t_counter_sig -> d . sign -> cert, i)))

t_success = MCDeployThrowOpenSSL(kMCDeployErrorBadTimestamp);

// Now encode the counter signature...

uint8_t *t_counter_sig_data;

uint32_t t_counter_sig_length;

t_counter_sig_data = nil;