nhyatt/osslsigncode
1
0
Fork 0
mirror of https://github.com/mtrojnar/osslsigncode.git synced 2025-04-05 09:08:04 -05:00
Code Issues Projects Releases Wiki Activity

Squash -Wcast-qual and -Wconversion warnings

Browse Source
This commit is contained in:
olszomal 2022-06-23 17:41:01 +02:00 committed by Michał Trojnara
parent f42459ff09
commit 1d0918c84d
3 changed files with 172 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
msi.c
View File

@ -691,7 +691,7 @@ int msi_hash_dir(MSI_FILE *msi, MSI_DIRENT *dirent, BIO *hash, int is_root)
OPENSSL_free(indata); OPENSSL_free(indata);
goto out; goto out;
} }
BIO_write(hash, indata, inlen); BIO_write(hash, indata, (int)inlen);
OPENSSL_free(indata); OPENSSL_free(indata);
} }
if (child->type == DIR_STORAGE) { if (child->type == DIR_STORAGE) {
@ -714,7 +714,7 @@ int msi_calc_digest(char *indata, int mdtype, u_char *mdbuf, uint32_t fileend)
uint32_t n; uint32_t n;
int ret = 0; int ret = 0;
const EVP_MD *md = EVP_get_digestbynid(mdtype); const EVP_MD *md = EVP_get_digestbynid(mdtype);
BIO *bio = BIO_new_mem_buf(indata, fileend); BIO *bio = BIO_new_mem_buf(indata, (int)fileend);
EVP_MD_CTX *mdctx = EVP_MD_CTX_new(); EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
if (!EVP_DigestInit(mdctx, md)) { if (!EVP_DigestInit(mdctx, md)) {
@ -731,11 +731,11 @@ int msi_calc_digest(char *indata, int mdtype, u_char *mdbuf, uint32_t fileend)
uint32_t want = fileend - n; uint32_t want = fileend - n;
if (want > sizeof bfb) if (want > sizeof bfb)
want = sizeof bfb; want = sizeof bfb;
l = BIO_read(bio, bfb, want); l = BIO_read(bio, bfb, (int)want);
if (l <= 0) if (l <= 0)
break; break;
EVP_DigestUpdate(mdctx, bfb, l); EVP_DigestUpdate(mdctx, bfb, (size_t)l);
n += l; n += (uint32_t)l;
} }
EVP_DigestFinal(mdctx, mdbuf, NULL); EVP_DigestFinal(mdctx, mdbuf, NULL);
ret = 1; /* OK */ ret = 1; /* OK */
@ -745,34 +745,34 @@ out:
return ret; return ret;
} }
static void ministream_append(MSI_OUT *out, char *buf, int len) static void ministream_append(MSI_OUT *out, char *buf, uint32_t len)
{ {
uint32_t needSectors = (len + out->sectorSize - 1) / out->sectorSize; uint32_t needSectors = (len + out->sectorSize - 1) / out->sectorSize;
if (out->miniStreamLen + len >= out->ministreamsMemallocCount * out->sectorSize) { if (out->miniStreamLen + len >= out->ministreamsMemallocCount * out->sectorSize) {
out->ministreamsMemallocCount += needSectors; out->ministreamsMemallocCount += needSectors;
out->ministream = OPENSSL_realloc(out->ministream, out->ministreamsMemallocCount * out->sectorSize); out->ministream = OPENSSL_realloc(out->ministream, (size_t)(out->ministreamsMemallocCount * out->sectorSize));
} }
memcpy(out->ministream + out->miniStreamLen, buf, len); memcpy(out->ministream + out->miniStreamLen, buf, (size_t)len);
out->miniStreamLen += len; out->miniStreamLen += len;
} }
static void minifat_append(MSI_OUT *out, char *buf, int len) static void minifat_append(MSI_OUT *out, char *buf, uint32_t len)
{ {
if (out->minifatLen == out->minifatMemallocCount * out->sectorSize) { if (out->minifatLen == out->minifatMemallocCount * out->sectorSize) {
out->minifatMemallocCount += 1; out->minifatMemallocCount += 1;
out->minifat = OPENSSL_realloc(out->minifat, out->minifatMemallocCount * out->sectorSize); out->minifat = OPENSSL_realloc(out->minifat, (size_t)(out->minifatMemallocCount * out->sectorSize));
} }
memcpy(out->minifat + out->minifatLen, buf, len); memcpy(out->minifat + out->minifatLen, buf, (size_t)len);
out->minifatLen += len; out->minifatLen += len;
} }
static void fat_append(MSI_OUT *out, char *buf, int len) static void fat_append(MSI_OUT *out, char *buf, uint32_t len)
{ {
if (out->fatLen == out->fatMemallocCount * out->sectorSize) { if (out->fatLen == out->fatMemallocCount * out->sectorSize) {
out->fatMemallocCount += 1; out->fatMemallocCount += 1;
out->fat = OPENSSL_realloc(out->fat, out->fatMemallocCount * out->sectorSize); out->fat = OPENSSL_realloc(out->fat, (size_t)(out->fatMemallocCount * out->sectorSize));
} }
memcpy(out->fat + out->fatLen, buf, len); memcpy(out->fat + out->fatLen, buf, (size_t)len);
out->fatLen += len; out->fatLen += len;
} }
@ -837,7 +837,7 @@ static int dirent_insert(MSI_DIRENT *dirent, const u_char *name, uint16_t nameLe
return 1; /* OK */ return 1; /* OK */
} }
static int signature_insert(MSI_DIRENT *dirent, int len_msiex) static int signature_insert(MSI_DIRENT *dirent, uint32_t len_msiex)
{ {
if (len_msiex > 0) { if (len_msiex > 0) {
if (!dirent_insert(dirent, digital_signature_ex, sizeof digital_signature_ex)) { if (!dirent_insert(dirent, digital_signature_ex, sizeof digital_signature_ex)) {
@ -854,8 +854,8 @@ static int signature_insert(MSI_DIRENT *dirent, int len_msiex)
return 1; /* OK */ return 1; /* OK */
} }
static int stream_read(MSI_FILE *msi, MSI_ENTRY *entry, u_char *p_msi, int len_msi, static uint32_t stream_read(MSI_FILE *msi, MSI_ENTRY *entry, u_char *p_msi, uint32_t len_msi,
u_char *p_msiex, int len_msiex, char **indata, int inlen, int is_root) u_char *p_msiex, uint32_t len_msiex, char **indata, uint32_t inlen, int is_root)
{ {
if (is_root && !memcmp(entry->name, digital_signature, sizeof digital_signature)) { if (is_root && !memcmp(entry->name, digital_signature, sizeof digital_signature)) {
*indata = (char *)p_msi; *indata = (char *)p_msi;
@ -873,8 +873,8 @@ static int stream_read(MSI_FILE *msi, MSI_ENTRY *entry, u_char *p_msi, int len_m
} }
/* Recursively handle data from MSI_DIRENT struct */ /* Recursively handle data from MSI_DIRENT struct */
static int stream_handle(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p_msi, int len_msi, static int stream_handle(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p_msi, uint32_t len_msi,
u_char *p_msiex, int len_msiex, BIO *outdata, MSI_OUT *out, int is_root) u_char *p_msiex, uint32_t len_msiex, BIO *outdata, MSI_OUT *out, int is_root)
{ {
int i; int i;
@ -911,15 +911,15 @@ static int stream_handle(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p_msi, int l
ministream_append(out, indata, inlen); ministream_append(out, indata, inlen);
/* fill to the end with known data, such as all zeroes */ /* fill to the end with known data, such as all zeroes */
if (inlen % msi->m_minisectorSize > 0) { if (inlen % msi->m_minisectorSize > 0) {
int remain = msi->m_minisectorSize - inlen % msi->m_minisectorSize; uint32_t remain = msi->m_minisectorSize - inlen % msi->m_minisectorSize;
memset(buf, 0, remain); memset(buf, 0, (size_t)remain);
ministream_append(out, buf, remain); ministream_append(out, buf, remain);
} }
while (inlen > msi->m_minisectorSize) { while (inlen > msi->m_minisectorSize) {
out->miniSectorNum += 1; out->miniSectorNum += 1;
PUT_UINT32_LE(out->miniSectorNum, buf); PUT_UINT32_LE(out->miniSectorNum, buf);
minifat_append(out, buf, 4); minifat_append(out, buf, 4);
inlen -= (uint32_t)msi->m_minisectorSize; inlen -= msi->m_minisectorSize;
} }
PUT_UINT32_LE(ENDOFCHAIN, buf); PUT_UINT32_LE(ENDOFCHAIN, buf);
minifat_append(out, buf, 4); minifat_append(out, buf, 4);
@ -928,19 +928,19 @@ static int stream_handle(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p_msi, int l
/* set the first sector location if this is a stream object */ /* set the first sector location if this is a stream object */
child->entry->startSectorLocation = out->sectorNum; child->entry->startSectorLocation = out->sectorNum;
/* stream save */ /* stream save */
BIO_write(outdata, indata, inlen); BIO_write(outdata, indata, (int)inlen);
/* fill to the end with known data, such as all zeroes */ /* fill to the end with known data, such as all zeroes */
if (inlen % out->sectorSize > 0) { if (inlen % out->sectorSize > 0) {
int remain = out->sectorSize - inlen % out->sectorSize; uint32_t remain = out->sectorSize - inlen % out->sectorSize;
memset(buf, 0, remain); memset(buf, 0, (size_t)remain);
BIO_write(outdata, buf, remain); BIO_write(outdata, buf, (int)remain);
} }
/* set a sector chain in the FAT */ /* set a sector chain in the FAT */
while (inlen > out->sectorSize) { while (inlen > out->sectorSize) {
out->sectorNum += 1; out->sectorNum += 1;
PUT_UINT32_LE(out->sectorNum, buf); PUT_UINT32_LE(out->sectorNum, buf);
fat_append(out, buf, 4); fat_append(out, buf, 4);
inlen -= (uint32_t)out->sectorSize; inlen -= out->sectorSize;
} }
PUT_UINT32_LE(ENDOFCHAIN, buf); PUT_UINT32_LE(ENDOFCHAIN, buf);
fat_append(out, buf, 4); fat_append(out, buf, 4);
@ -955,19 +955,19 @@ static int stream_handle(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p_msi, int l
static void ministream_save(MSI_DIRENT *dirent, BIO *outdata, MSI_OUT *out) static void ministream_save(MSI_DIRENT *dirent, BIO *outdata, MSI_OUT *out)
{ {
char buf[MAX_SECTOR_SIZE]; char buf[MAX_SECTOR_SIZE];
int remain, i; uint32_t i, remain;
int ministreamSectorsCount = (out->miniStreamLen + out->sectorSize - 1) / out->sectorSize; uint32_t ministreamSectorsCount = (out->miniStreamLen + out->sectorSize - 1) / out->sectorSize;
/* set the first sector of the mini stream in the entry root object */ /* set the first sector of the mini stream in the entry root object */
dirent->entry->startSectorLocation = out->sectorNum; dirent->entry->startSectorLocation = out->sectorNum;
/* ministream save */ /* ministream save */
BIO_write(outdata, out->ministream, out->miniStreamLen); BIO_write(outdata, out->ministream, (int)out->miniStreamLen);
OPENSSL_free(out->ministream); OPENSSL_free(out->ministream);
/* fill to the end with known data, such as all zeroes */ /* fill to the end with known data, such as all zeroes */
if (out->miniStreamLen % out->sectorSize > 0) { if (out->miniStreamLen % out->sectorSize > 0) {
remain = out->sectorSize - out->miniStreamLen % out->sectorSize; remain = out->sectorSize - out->miniStreamLen % out->sectorSize;
memset(buf, 0, remain); memset(buf, 0, (size_t)remain);
BIO_write(outdata, buf, remain); BIO_write(outdata, buf, (int)remain);
} }
/* set a sector chain in the FAT */ /* set a sector chain in the FAT */
for (i=1; i<ministreamSectorsCount; i++) { for (i=1; i<ministreamSectorsCount; i++) {
@ -984,7 +984,7 @@ static void ministream_save(MSI_DIRENT *dirent, BIO *outdata, MSI_OUT *out)
static void minifat_save(BIO *outdata, MSI_OUT *out) static void minifat_save(BIO *outdata, MSI_OUT *out)
{ {
char buf[MAX_SECTOR_SIZE]; char buf[MAX_SECTOR_SIZE];
int i,remain; uint32_t i, remain;
/* set Mini FAT Starting Sector Location in the header */ /* set Mini FAT Starting Sector Location in the header */
if (out->minifatLen == 0) { if (out->minifatLen == 0) {
@ -995,7 +995,7 @@ static void minifat_save(BIO *outdata, MSI_OUT *out)
PUT_UINT32_LE(out->sectorNum, buf); PUT_UINT32_LE(out->sectorNum, buf);
memcpy(out->header + HEADER_MINI_FAT_SECTOR_LOC, buf, 4); memcpy(out->header + HEADER_MINI_FAT_SECTOR_LOC, buf, 4);
/* minifat save */ /* minifat save */
BIO_write(outdata, out->minifat, out->minifatLen); BIO_write(outdata, out->minifat, (int)out->minifatLen);
/* marks the end of the stream */ /* marks the end of the stream */
PUT_UINT32_LE(ENDOFCHAIN, buf); PUT_UINT32_LE(ENDOFCHAIN, buf);
BIO_write(outdata, buf, 4); BIO_write(outdata, buf, 4);
@ -1003,8 +1003,8 @@ static void minifat_save(BIO *outdata, MSI_OUT *out)
/* empty unallocated free sectors in the last Mini FAT sector */ /* empty unallocated free sectors in the last Mini FAT sector */
if (out->minifatLen % out->sectorSize > 0) { if (out->minifatLen % out->sectorSize > 0) {
remain = out->sectorSize - out->minifatLen % out->sectorSize; remain = out->sectorSize - out->minifatLen % out->sectorSize;
memset(buf, FREESECT, remain); memset(buf, (int)FREESECT, (size_t)remain);
BIO_write(outdata, buf, remain); BIO_write(outdata, buf, (int)remain);
} }
/* set a sector chain in the FAT */ /* set a sector chain in the FAT */
out->minifatSectorsCount = (out->minifatLen + out->sectorSize - 1) / out->sectorSize; out->minifatSectorsCount = (out->minifatLen + out->sectorSize - 1) / out->sectorSize;
@ -1059,13 +1059,13 @@ static char *msi_unused_dirent_get()
/* initialise 127 bytes */ /* initialise 127 bytes */
memset(data, 0, DIRENT_SIZE); memset(data, 0, DIRENT_SIZE);
memset(data + DIRENT_LEFT_SIBLING_ID, NOSTREAM, 4); memset(data + DIRENT_LEFT_SIBLING_ID, (int)NOSTREAM, 4);
memset(data + DIRENT_RIGHT_SIBLING_ID, NOSTREAM, 4); memset(data + DIRENT_RIGHT_SIBLING_ID, (int)NOSTREAM, 4);
memset(data + DIRENT_CHILD_ID, NOSTREAM, 4); memset(data + DIRENT_CHILD_ID, (int)NOSTREAM, 4);
return data; return data;
} }
static int dirents_save(MSI_DIRENT *dirent, BIO *outdata, MSI_OUT *out, int *streamId, int count, int last) static int dirents_save(MSI_DIRENT *dirent, BIO *outdata, MSI_OUT *out, uint32_t *streamId, int count, int last)
{ {
int i, childenNum; int i, childenNum;
char *entry; char *entry;
@ -1083,7 +1083,7 @@ static int dirents_save(MSI_DIRENT *dirent, BIO *outdata, MSI_OUT *out, int *str
} else { } else {
/* make linked list rather than tree, only use next - right sibling */ /* make linked list rather than tree, only use next - right sibling */
count += childenNum; count += childenNum;
dirent->entry->rightSiblingID = *streamId + count + 1; dirent->entry->rightSiblingID = *streamId + (uint32_t)count + 1;
} }
} else { /* DIR_ROOT */ } else { /* DIR_ROOT */
dirent->entry->rightSiblingID = NOSTREAM; dirent->entry->rightSiblingID = NOSTREAM;
@ -1122,8 +1122,7 @@ static void dirtree_save(MSI_DIRENT *dirent, BIO *outdata, MSI_OUT *out)
{ {
char buf[MAX_SECTOR_SIZE]; char buf[MAX_SECTOR_SIZE];
char *unused_entry; char *unused_entry;
int i, remain; uint32_t i, remain, streamId = 0;
int streamId = 0;
/* set Directory Starting Sector Location in the header */ /* set Directory Starting Sector Location in the header */
PUT_UINT32_LE(out->sectorNum, buf); PUT_UINT32_LE(out->sectorNum, buf);
@ -1162,7 +1161,7 @@ static void dirtree_save(MSI_DIRENT *dirent, BIO *outdata, MSI_OUT *out)
static int fat_save(BIO *outdata, MSI_OUT *out) static int fat_save(BIO *outdata, MSI_OUT *out)
{ {
char buf[MAX_SECTOR_SIZE]; char buf[MAX_SECTOR_SIZE];
int i, remain; uint32_t i, remain;
remain = (out->fatLen + out->sectorSize - 1) / out->sectorSize; remain = (out->fatLen + out->sectorSize - 1) / out->sectorSize;
out->fatSectorsCount = (out->fatLen + remain * 4 + out->sectorSize - 1) / out->sectorSize; out->fatSectorsCount = (out->fatLen + remain * 4 + out->sectorSize - 1) / out->sectorSize;
@ -1187,17 +1186,17 @@ static int fat_save(BIO *outdata, MSI_OUT *out)
/* empty unallocated free sectors in the last FAT sector */ /* empty unallocated free sectors in the last FAT sector */
if (out->fatLen % out->sectorSize > 0) { if (out->fatLen % out->sectorSize > 0) {
remain = out->sectorSize - out->fatLen % out->sectorSize; remain = out->sectorSize - out->fatLen % out->sectorSize;
memset(buf, FREESECT, remain); memset(buf, (int)FREESECT, (size_t)remain);
fat_append(out, buf, remain); fat_append(out, buf, remain);
} }
BIO_write(outdata, out->fat, out->fatLen); BIO_write(outdata, out->fat, (int)out->fatLen);
return 1; /* OK */ return 1; /* OK */
} }
static void header_save(BIO *outdata, MSI_OUT *out) static void header_save(BIO *outdata, MSI_OUT *out)
{ {
char buf[MAX_SECTOR_SIZE]; char buf[MAX_SECTOR_SIZE];
int remain; uint32_t remain;
/* set Number of FAT sectors in the header */ /* set Number of FAT sectors in the header */
PUT_UINT32_LE(out->fatSectorsCount, buf); PUT_UINT32_LE(out->fatSectorsCount, buf);
@ -1216,8 +1215,8 @@ static void header_save(BIO *outdata, MSI_OUT *out)
BIO_write(outdata, out->header, HEADER_SIZE); BIO_write(outdata, out->header, HEADER_SIZE);
remain = out->sectorSize - HEADER_SIZE; remain = out->sectorSize - HEADER_SIZE;
memset(buf, 0, remain); memset(buf, 0, (size_t)remain);
BIO_write(outdata, buf, remain); BIO_write(outdata, buf, (int)remain);
} }
static char *header_new(MSI_FILE_HDR *hdr, MSI_OUT *out) static char *header_new(MSI_FILE_HDR *hdr, MSI_OUT *out)
@ -1267,14 +1266,14 @@ static char *header_new(MSI_FILE_HDR *hdr, MSI_OUT *out)
memset(data + HEADER_DIFAT_SECTORS_NUM, 0, 4); /* no DIFAT */ memset(data + HEADER_DIFAT_SECTORS_NUM, 0, 4); /* no DIFAT */
memcpy(data + HEADER_DIFAT, dead_food, 4); /* sector number for FAT */ memcpy(data + HEADER_DIFAT, dead_food, 4); /* sector number for FAT */
for (i = 1; i < DIFAT_IN_HEADER; i++) { for (i = 1; i < DIFAT_IN_HEADER; i++) {
memset(data + HEADER_DIFAT + 4*i, FREESECT, 4); /* free FAT sectors */ memset(data + HEADER_DIFAT + 4*i, (int)FREESECT, 4); /* free FAT sectors */
} }
return data; return data;
} }
static int msiout_set(MSI_FILE *msi, int len_msi, int len_msiex, MSI_OUT *out) static int msiout_set(MSI_FILE *msi, uint32_t len_msi, uint32_t len_msiex, MSI_OUT *out)
{ {
int msi_size, msiex_size; uint32_t msi_size, msiex_size;
out->sectorSize = msi->m_sectorSize; out->sectorSize = msi->m_sectorSize;
@ -1306,8 +1305,8 @@ static int msiout_set(MSI_FILE *msi, int len_msi, int len_msiex, MSI_OUT *out)
return 1; /* OK */ return 1; /* OK */
} }
int msi_file_write(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p_msi, int len_msi, int msi_file_write(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p_msi, uint32_t len_msi,
u_char *p_msiex, int len_msiex, BIO *outdata) u_char *p_msiex, uint32_t len_msiex, BIO *outdata)
{ {
MSI_OUT out; MSI_OUT out;
int ret = 0; int ret = 0;

47
msi.h
View File

@ -72,25 +72,25 @@
#define DIRENT_START_SECTOR_LOC 0x74 #define DIRENT_START_SECTOR_LOC 0x74
#define DIRENT_FILE_SIZE 0x78 #define DIRENT_FILE_SIZE 0x78
#define GET_UINT8_LE(p) ((u_char*)(p))[0] #define GET_UINT8_LE(p) ((const u_char *)(p))[0]
#define GET_UINT16_LE(p) (uint16_t)(((u_char*)(p))[0] | (((u_char*)(p))[1]<<8)) #define GET_UINT16_LE(p) (uint16_t)(((const u_char *)(p))[0] | \
(((const u_char *)(p))[1] << 8))
#define GET_UINT32_LE(p) (uint32_t)(((u_char*)(p))[0] | (((u_char*)(p))[1]<<8) | \ #define GET_UINT32_LE(p) (uint32_t)(((const u_char *)(p))[0] | \
(((u_char*)(p))[2]<<16) | (((u_char*)(p))[3]<<24)) (((const u_char *)(p))[1] << 8) | \
(((const u_char *)(p))[2] << 16) | \
(((const u_char *)(p))[3] << 24))
#define PUT_UINT8_LE(i,p) \ #define PUT_UINT8_LE(i, p) ((u_char *)(p))[0] = (u_char)((i) & 0xff);
((u_char*)(p))[0] = (i) & 0xff;
#define PUT_UINT16_LE(i,p) \ #define PUT_UINT16_LE(i,p) ((u_char *)(p))[0] = (u_char)((i) & 0xff); \
((u_char*)(p))[0] = (i) & 0xff; \ ((u_char *)(p))[1] = (u_char)(((i) >> 8) & 0xff)
((u_char*)(p))[1] = ((i)>>8) & 0xff
#define PUT_UINT32_LE(i,p) \ #define PUT_UINT32_LE(i,p) ((u_char *)(p))[0] = (u_char)((i) & 0xff); \
((u_char*)(p))[0] = (i) & 0xff; \ ((u_char *)(p))[1] = (u_char)(((i) >> 8) & 0xff); \
((u_char*)(p))[1] = ((i)>>8) & 0xff; \ ((u_char *)(p))[2] = (u_char)(((i) >> 16) & 0xff); \
((u_char*)(p))[2] = ((i)>>16) & 0xff; \ ((u_char *)(p))[3] = (u_char)(((i) >> 24) & 0xff)
((u_char*)(p))[3] = ((i)>>24) & 0xff
#ifndef FALSE #ifndef FALSE
#define FALSE 0 #define FALSE 0
@ -171,14 +171,14 @@ typedef struct {
uint32_t miniStreamLen; uint32_t miniStreamLen;
uint32_t minifatLen; uint32_t minifatLen;
uint32_t fatLen; uint32_t fatLen;
int ministreamsMemallocCount; uint32_t ministreamsMemallocCount;
int minifatMemallocCount; uint32_t minifatMemallocCount;
int fatMemallocCount; uint32_t fatMemallocCount;
int dirtreeSectorsCount; uint32_t dirtreeSectorsCount;
int minifatSectorsCount; uint32_t minifatSectorsCount;
int fatSectorsCount; uint32_t fatSectorsCount;
int miniSectorNum; uint32_t miniSectorNum;
int sectorNum; uint32_t sectorNum;
uint32_t sectorSize; uint32_t sectorSize;
} MSI_OUT; } MSI_OUT;
@ -224,7 +224,8 @@ int msi_prehash_dir(MSI_DIRENT *dirent, BIO *hash, int is_root);
int msi_hash_dir(MSI_FILE *msi, MSI_DIRENT *dirent, BIO *hash, int is_root); int msi_hash_dir(MSI_FILE *msi, MSI_DIRENT *dirent, BIO *hash, int is_root);
int msi_calc_digest(char *indata, int mdtype, u_char *mdbuf, uint32_t fileend); int msi_calc_digest(char *indata, int mdtype, u_char *mdbuf, uint32_t fileend);
int msi_dirent_delete(MSI_DIRENT *dirent, const u_char *name, uint16_t nameLen); int msi_dirent_delete(MSI_DIRENT *dirent, const u_char *name, uint16_t nameLen);
int msi_file_write(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p, int len, u_char *p_msiex, int len_msiex, BIO *outdata); int msi_file_write(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p, uint32_t len,
u_char *p_msiex, uint32_t len_msiex, BIO *outdata);
/* /*
Local Variables: Local Variables:

190
osslsigncode.c
View File

@ -252,7 +252,7 @@ typedef struct {
typedef struct { typedef struct {
uint32_t header_size; uint32_t header_size;
int pe32plus; uint32_t pe32plus;
uint16_t magic; uint16_t magic;
uint32_t pe_checksum; uint32_t pe_checksum;
uint32_t nrvas; uint32_t nrvas;
@ -469,7 +469,7 @@ IMPLEMENT_ASN1_FUNCTIONS(MsCtlContent)
typedef struct { typedef struct {
ASN1_BIT_STRING* flags; ASN1_BIT_STRING *flags;
SpcLink *file; SpcLink *file;
} SpcPeImageData; } SpcPeImageData;
@ -768,7 +768,7 @@ static void print_hash(const char *descript1, const char *descript2, const u_cha
static int compare_digests(u_char *mdbuf, u_char *cmdbuf, int mdtype) static int compare_digests(u_char *mdbuf, u_char *cmdbuf, int mdtype)
{ {
int mdlen = EVP_MD_size(EVP_get_digestbynid(mdtype)); int mdlen = EVP_MD_size(EVP_get_digestbynid(mdtype));
int mdok = !memcmp(mdbuf, cmdbuf, mdlen); int mdok = !memcmp(mdbuf, cmdbuf, (size_t)mdlen);
printf("Message digest algorithm : %s\n", OBJ_nid2sn(mdtype)); printf("Message digest algorithm : %s\n", OBJ_nid2sn(mdtype));
print_hash("Current message digest ", "", mdbuf, mdlen); print_hash("Current message digest ", "", mdbuf, mdlen);
print_hash("Calculated message digest ", mdok ? "\n" : " MISMATCH!!!\n", cmdbuf, mdlen); print_hash("Calculated message digest ", mdok ? "\n" : " MISMATCH!!!\n", cmdbuf, mdlen);
@ -796,7 +796,7 @@ static int blob_has_nl = 0;
/* /*
* Callback for writing received data * Callback for writing received data
*/ */
static size_t curl_write(void *ptr, size_t sz, size_t nmemb, void *stream) static int curl_write(void *ptr, size_t sz, size_t nmemb, void *stream)
{ {
if (sz*nmemb > 0 && !blob_has_nl) { if (sz*nmemb > 0 && !blob_has_nl) {
if (memchr(ptr, '\n', sz*nmemb)) if (memchr(ptr, '\n', sz*nmemb))
@ -869,7 +869,7 @@ static BIO *encode_rfc3161_request(PKCS7 *sig, const EVP_MD *md)
printf("Unable to set up the digest context\n"); printf("Unable to set up the digest context\n");
return NULL; /* FAILED */ return NULL; /* FAILED */
} }
EVP_DigestUpdate(mdctx, si->enc_digest->data, si->enc_digest->length); EVP_DigestUpdate(mdctx, si->enc_digest->data, (size_t)si->enc_digest->length);
EVP_DigestFinal(mdctx, mdbuf, NULL); EVP_DigestFinal(mdctx, mdbuf, NULL);
EVP_MD_CTX_free(mdctx); EVP_MD_CTX_free(mdctx);
@ -882,7 +882,7 @@ static BIO *encode_rfc3161_request(PKCS7 *sig, const EVP_MD *md)
req->certReq = (void*)0x1; req->certReq = (void*)0x1;
len = i2d_TimeStampReq(req, NULL); len = i2d_TimeStampReq(req, NULL);
p = OPENSSL_malloc(len); p = OPENSSL_malloc((size_t)len);
len = i2d_TimeStampReq(req, &p); len = i2d_TimeStampReq(req, &p);
p -= len; p -= len;
TimeStampReq_free(req); TimeStampReq_free(req);
@ -918,7 +918,7 @@ static BIO *encode_authenticode_request(PKCS7 *sig)
req->blob->signature = si->enc_digest; req->blob->signature = si->enc_digest;
len = i2d_TimeStampRequest(req, NULL); len = i2d_TimeStampRequest(req, NULL);
p = OPENSSL_malloc(len); p = OPENSSL_malloc((size_t)len);
len = i2d_TimeStampRequest(req, &p); len = i2d_TimeStampRequest(req, &p);
p -= len; p -= len;
req->blob->signature = NULL; req->blob->signature = NULL;
@ -938,7 +938,7 @@ static BIO *encode_authenticode_request(PKCS7 *sig)
* If successful the RFC 3161 timestamp will be written into * If successful the RFC 3161 timestamp will be written into
* the PKCS7 SignerInfo structure as an unauthorized attribute - cont[1]. * the PKCS7 SignerInfo structure as an unauthorized attribute - cont[1].
*/ */
static int decode_rfc3161_response(PKCS7 *sig, BIO *bin, int verbose) static CURLcode decode_rfc3161_response(PKCS7 *sig, BIO *bin, int verbose)
{ {
PKCS7_SIGNER_INFO *si; PKCS7_SIGNER_INFO *si;
STACK_OF(X509_ATTRIBUTE) *attrs; STACK_OF(X509_ATTRIBUTE) *attrs;
@ -968,7 +968,7 @@ static int decode_rfc3161_response(PKCS7 *sig, BIO *bin, int verbose)
TimeStampResp_free(reply); TimeStampResp_free(reply);
return 1; /* FAILED */ return 1; /* FAILED */
} }
if (((len = i2d_PKCS7(reply->token, NULL)) <= 0) || (p = OPENSSL_malloc(len)) == NULL) { if (((len = i2d_PKCS7(reply->token, NULL)) <= 0) || (p = OPENSSL_malloc((size_t)len)) == NULL) {
if (verbose) { if (verbose) {
printf("Failed to convert pkcs7: %d\n", len); printf("Failed to convert pkcs7: %d\n", len);
ERR_print_errors_fp(stdout); ERR_print_errors_fp(stdout);
@ -994,7 +994,7 @@ static int decode_rfc3161_response(PKCS7 *sig, BIO *bin, int verbose)
* If successful the authenticode timestamp will be written into * If successful the authenticode timestamp will be written into
* the PKCS7 SignerInfo structure as an unauthorized attribute - cont[1]. * the PKCS7 SignerInfo structure as an unauthorized attribute - cont[1].
*/ */
static int decode_authenticode_response(PKCS7 *sig, BIO *bin, int verbose) static CURLcode decode_authenticode_response(PKCS7 *sig, BIO *bin, int verbose)
{ {
PKCS7 *p7; PKCS7 *p7;
PKCS7_SIGNER_INFO *info, *si; PKCS7_SIGNER_INFO *info, *si;
@ -1022,7 +1022,7 @@ static int decode_authenticode_response(PKCS7 *sig, BIO *bin, int verbose)
info = sk_PKCS7_SIGNER_INFO_value(signer_info, 0); info = sk_PKCS7_SIGNER_INFO_value(signer_info, 0);
if (!info) if (!info)
return 1; /* FAILED */ return 1; /* FAILED */
if (((len = i2d_PKCS7_SIGNER_INFO(info, NULL)) <= 0) || (p = OPENSSL_malloc(len)) == NULL) { if (((len = i2d_PKCS7_SIGNER_INFO(info, NULL)) <= 0) || (p = OPENSSL_malloc((size_t)len)) == NULL) {
if (verbose) { if (verbose) {
printf("Failed to convert signer info: %d\n", len); printf("Failed to convert signer info: %d\n", len);
ERR_print_errors_fp(stdout); ERR_print_errors_fp(stdout);
@ -1065,7 +1065,7 @@ static int add_timestamp(PKCS7 *sig, char *url, char *proxy, int rfc3161,
CURLcode res; CURLcode res;
BIO *bout, *bin; BIO *bout, *bin;
u_char *p = NULL; u_char *p = NULL;
int len = 0; long len = 0;
if (!url) if (!url)
return 1; /* FAILED */ return 1; /* FAILED */
@ -1501,7 +1501,7 @@ static SpcLink *get_obsolete_link(void)
} }
static u_char *pe_calc_page_hash(char *indata, uint32_t header_size, static u_char *pe_calc_page_hash(char *indata, uint32_t header_size,
int pe32plus, uint32_t sigpos, int phtype, int *rphlen) uint32_t pe32plus, uint32_t sigpos, int phtype, int *rphlen)
{ {
uint16_t nsections, opthdr_size; uint16_t nsections, opthdr_size;
uint32_t pagesize, hdrsize; uint32_t pagesize, hdrsize;
@ -1520,10 +1520,10 @@ static u_char *pe_calc_page_hash(char *indata, uint32_t header_size,
pagesize = GET_UINT32_LE(indata + header_size + 56); pagesize = GET_UINT32_LE(indata + header_size + 56);
hdrsize = GET_UINT32_LE(indata + header_size + 84); hdrsize = GET_UINT32_LE(indata + header_size + 84);
pphlen = 4 + EVP_MD_size(md); pphlen = 4 + EVP_MD_size(md);
phlen = pphlen * (3 + nsections + sigpos / pagesize); phlen = pphlen * (3 + (int)nsections + (int)(sigpos / pagesize));
res = OPENSSL_malloc(phlen); res = OPENSSL_malloc((size_t)phlen);
zeroes = OPENSSL_zalloc(pagesize); zeroes = OPENSSL_zalloc((size_t)pagesize);
EVP_DigestUpdate(mdctx, indata, header_size + 88); EVP_DigestUpdate(mdctx, indata, header_size + 88);
EVP_DigestUpdate(mdctx, indata + header_size + 92, 60 + pe32plus*16); EVP_DigestUpdate(mdctx, indata + header_size + 92, 60 + pe32plus*16);
@ -1554,7 +1554,7 @@ static u_char *pe_calc_page_hash(char *indata, uint32_t header_size,
} }
EVP_MD_CTX_free(mdctx); EVP_MD_CTX_free(mdctx);
PUT_UINT32_LE(lastpos, res + pi*pphlen); PUT_UINT32_LE(lastpos, res + pi*pphlen);
memset(res + pi*pphlen + 4, 0, EVP_MD_size(md)); memset(res + pi*pphlen + 4, 0, (size_t)EVP_MD_size(md));
pi++; pi++;
OPENSSL_free(zeroes); OPENSSL_free(zeroes);
*rphlen = pi*pphlen; *rphlen = pi*pphlen;
@ -1589,7 +1589,7 @@ static SpcLink *get_page_hash_link(int phtype, char *indata, FILE_HEADER *header
oset = sk_ASN1_TYPE_new_null(); oset = sk_ASN1_TYPE_new_null();
sk_ASN1_TYPE_push(oset, tostr); sk_ASN1_TYPE_push(oset, tostr);
l = i2d_ASN1_SET_ANY(oset, NULL); l = i2d_ASN1_SET_ANY(oset, NULL);
tmp = p = OPENSSL_malloc(l); tmp = p = OPENSSL_malloc((size_t)l);
i2d_ASN1_SET_ANY(oset, &tmp); i2d_ASN1_SET_ANY(oset, &tmp);
ASN1_TYPE_free(tostr); ASN1_TYPE_free(tostr);
sk_ASN1_TYPE_free(oset); sk_ASN1_TYPE_free(oset);
@ -1603,7 +1603,7 @@ static SpcLink *get_page_hash_link(int phtype, char *indata, FILE_HEADER *header
ASN1_STRING_set(aval->value->value.set, p, l); ASN1_STRING_set(aval->value->value.set, p, l);
OPENSSL_free(p); OPENSSL_free(p);
l = i2d_SpcAttributeTypeAndOptionalValue(aval, NULL); l = i2d_SpcAttributeTypeAndOptionalValue(aval, NULL);
tmp = p = OPENSSL_malloc(l); tmp = p = OPENSSL_malloc((size_t)l);
i2d_SpcAttributeTypeAndOptionalValue(aval, &tmp); i2d_SpcAttributeTypeAndOptionalValue(aval, &tmp);
SpcAttributeTypeAndOptionalValue_free(aval); SpcAttributeTypeAndOptionalValue_free(aval);
@ -1616,7 +1616,7 @@ static SpcLink *get_page_hash_link(int phtype, char *indata, FILE_HEADER *header
aset = sk_ASN1_TYPE_new_null(); aset = sk_ASN1_TYPE_new_null();
sk_ASN1_TYPE_push(aset, taval); sk_ASN1_TYPE_push(aset, taval);
l = i2d_ASN1_SET_ANY(aset, NULL); l = i2d_ASN1_SET_ANY(aset, NULL);
tmp = p = OPENSSL_malloc(l); tmp = p = OPENSSL_malloc((size_t)l);
l = i2d_ASN1_SET_ANY(aset, &tmp); l = i2d_ASN1_SET_ANY(aset, &tmp);
ASN1_TYPE_free(taval); ASN1_TYPE_free(taval);
sk_ASN1_TYPE_free(aset); sk_ASN1_TYPE_free(aset);
@ -1653,7 +1653,7 @@ static int get_indirect_data_blob(u_char **blob, int *len, GLOBAL_OPTIONS *optio
if (type == FILE_TYPE_CAB) { if (type == FILE_TYPE_CAB) {
SpcLink *link = get_obsolete_link(); SpcLink *link = get_obsolete_link();
l = i2d_SpcLink(link, NULL); l = i2d_SpcLink(link, NULL);
p = OPENSSL_malloc(l); p = OPENSSL_malloc((size_t)l);
i2d_SpcLink(link, &p); i2d_SpcLink(link, &p);
p -= l; p -= l;
dtype = OBJ_txt2obj(SPC_CAB_DATA_OBJID, 1); dtype = OBJ_txt2obj(SPC_CAB_DATA_OBJID, 1);
@ -1674,7 +1674,7 @@ static int get_indirect_data_blob(u_char **blob, int *len, GLOBAL_OPTIONS *optio
pid->file = get_obsolete_link(); pid->file = get_obsolete_link();
} }
l = i2d_SpcPeImageData(pid, NULL); l = i2d_SpcPeImageData(pid, NULL);
p = OPENSSL_malloc(l); p = OPENSSL_malloc((size_t)l);
i2d_SpcPeImageData(pid, &p); i2d_SpcPeImageData(pid, &p);
p -= l; p -= l;
dtype = OBJ_txt2obj(SPC_PE_IMAGE_DATA_OBJID, 1); dtype = OBJ_txt2obj(SPC_PE_IMAGE_DATA_OBJID, 1);
@ -1689,7 +1689,7 @@ static int get_indirect_data_blob(u_char **blob, int *len, GLOBAL_OPTIONS *optio
ASN1_INTEGER_set(si->f, 0); ASN1_INTEGER_set(si->f, 0);
ASN1_OCTET_STRING_set(si->string, msistr, sizeof msistr); ASN1_OCTET_STRING_set(si->string, msistr, sizeof msistr);
l = i2d_SpcSipInfo(si, NULL); l = i2d_SpcSipInfo(si, NULL);
p = OPENSSL_malloc(l); p = OPENSSL_malloc((size_t)l);
i2d_SpcSipInfo(si, &p); i2d_SpcSipInfo(si, &p);
p -= l; p -= l;
dtype = OBJ_txt2obj(SPC_SIPINFO_OBJID, 1); dtype = OBJ_txt2obj(SPC_SIPINFO_OBJID, 1);
@ -1707,13 +1707,13 @@ static int get_indirect_data_blob(u_char **blob, int *len, GLOBAL_OPTIONS *optio
idc->messageDigest->digestAlgorithm->parameters->type = V_ASN1_NULL; idc->messageDigest->digestAlgorithm->parameters->type = V_ASN1_NULL;
hashlen = EVP_MD_size(options->md); hashlen = EVP_MD_size(options->md);
hash = OPENSSL_malloc(hashlen); hash = OPENSSL_malloc((size_t)hashlen);
memset(hash, 0, hashlen); memset(hash, 0, (size_t)hashlen);
ASN1_OCTET_STRING_set(idc->messageDigest->digest, hash, hashlen); ASN1_OCTET_STRING_set(idc->messageDigest->digest, hash, hashlen);
OPENSSL_free(hash); OPENSSL_free(hash);
*len = i2d_SpcIndirectDataContent(idc, NULL); *len = i2d_SpcIndirectDataContent(idc, NULL);
*blob = OPENSSL_malloc(*len); *blob = OPENSSL_malloc((size_t)*len);
p = *blob; p = *blob;
i2d_SpcIndirectDataContent(idc, &p); i2d_SpcIndirectDataContent(idc, &p);
SpcIndirectDataContent_free(idc); SpcIndirectDataContent_free(idc);
@ -1729,7 +1729,7 @@ static int set_signing_blob(PKCS7 *sig, BIO *hash, u_char *buf, int len)
PKCS7 *td7; PKCS7 *td7;
mdlen = BIO_gets(hash, (char*)mdbuf, EVP_MAX_MD_SIZE); mdlen = BIO_gets(hash, (char*)mdbuf, EVP_MAX_MD_SIZE);
memcpy(buf+len, mdbuf, mdlen); memcpy(buf+len, mdbuf, (size_t)mdlen);
seqhdrlen = asn1_simple_hdr_len(buf, len); seqhdrlen = asn1_simple_hdr_len(buf, len);
if ((sigbio = PKCS7_dataInit(sig, NULL)) == NULL) { if ((sigbio = PKCS7_dataInit(sig, NULL)) == NULL) {
@ -1802,7 +1802,7 @@ static int set_indirect_data_blob(PKCS7 *sig, BIO *hash, file_type_t type,
if (!get_indirect_data_blob(&p, &len, options, header, type, indata)) if (!get_indirect_data_blob(&p, &len, options, header, type, indata))
return 0; /* FAILED */ return 0; /* FAILED */
memcpy(buf, p, len); memcpy(buf, p, (size_t)len);
OPENSSL_free(p); OPENSSL_free(p);
if (!set_signing_blob(sig, hash, buf, len)) { if (!set_signing_blob(sig, hash, buf, len)) {
OPENSSL_free(buf); OPENSSL_free(buf);
@ -1886,7 +1886,7 @@ static int verify_leaf_hash(X509 *leaf, const char *leafhash)
printf("Unable to set up the digest context\n"); printf("Unable to set up the digest context\n");
goto out; goto out;
} }
certlen = i2d_X509(leaf, NULL); certlen = (size_t)i2d_X509(leaf, NULL);
certbuf = OPENSSL_malloc(certlen); certbuf = OPENSSL_malloc(certlen);
tmp = certbuf; tmp = certbuf;
i2d_X509(leaf, &tmp); i2d_X509(leaf, &tmp);
@ -1896,7 +1896,7 @@ static int verify_leaf_hash(X509 *leaf, const char *leafhash)
EVP_MD_CTX_free(ctx); EVP_MD_CTX_free(ctx);
/* compare the provided hash against the computed hash */ /* compare the provided hash against the computed hash */
if (memcmp(mdbuf, cmdbuf, EVP_MD_size(md))) { if (memcmp(mdbuf, cmdbuf, (size_t)EVP_MD_size(md))) {
print_hash("\nLeaf hash value mismatch", "computed", cmdbuf, EVP_MD_size(md)); print_hash("\nLeaf hash value mismatch", "computed", cmdbuf, EVP_MD_size(md));
goto out; goto out;
} }
@ -2238,7 +2238,7 @@ static CMS_ContentInfo *cms_get_timestamp(PKCS7_SIGNED *p7_signed, PKCS7_SIGNER_
} }
/* Convert PKCS7 into CMS_ContentInfo */ /* Convert PKCS7 into CMS_ContentInfo */
if (((len = i2d_PKCS7(p7, NULL)) <= 0) || (p = OPENSSL_malloc(len)) == NULL) { if (((len = i2d_PKCS7(p7, NULL)) <= 0) || (p = OPENSSL_malloc((size_t)len)) == NULL) {
printf("Failed to convert pkcs7: %d\n", len); printf("Failed to convert pkcs7: %d\n", len);
goto out; goto out;
} }
@ -2355,7 +2355,7 @@ static void get_signed_attributes(SIGNATURE *signature, STACK_OF(X509_ATTRIBUTE)
u_char *desc; u_char *desc;
int len = ASN1_STRING_to_UTF8(&desc, opus->programName->value.unicode); int len = ASN1_STRING_to_UTF8(&desc, opus->programName->value.unicode);
if (len >= 0) { if (len >= 0) {
signature->desc = OPENSSL_strndup((char *)desc, len); signature->desc = OPENSSL_strndup((char *)desc, (size_t)len);
OPENSSL_free(desc); OPENSSL_free(desc);
} }
} else { } else {
@ -2555,14 +2555,14 @@ static int TST_verify(CMS_ContentInfo *timestamp, PKCS7_SIGNER_INFO *si)
printf("Unable to set up the digest context\n"); printf("Unable to set up the digest context\n");
return 0; /* FAILED */ return 0; /* FAILED */
} }
EVP_DigestUpdate(mdctx, si->enc_digest->data, si->enc_digest->length); EVP_DigestUpdate(mdctx, si->enc_digest->data, (size_t)si->enc_digest->length);
EVP_DigestFinal(mdctx, mdbuf, NULL); EVP_DigestFinal(mdctx, mdbuf, NULL);
EVP_MD_CTX_free(mdctx); EVP_MD_CTX_free(mdctx);
/* compare the provided hash against the computed hash */ /* compare the provided hash against the computed hash */
hash = token->messageImprint->digest; hash = token->messageImprint->digest;
/* hash->length == EVP_MD_size(md) */ /* hash->length == EVP_MD_size(md) */
if (memcmp(mdbuf, hash->data, hash->length)) { if (memcmp(mdbuf, hash->data, (size_t)hash->length)) {
printf("Hash value mismatch:\n\tMessage digest algorithm: %s\n", printf("Hash value mismatch:\n\tMessage digest algorithm: %s\n",
(md_nid == NID_undef) ? "UNKNOWN" : OBJ_nid2ln(md_nid)); (md_nid == NID_undef) ? "UNKNOWN" : OBJ_nid2ln(md_nid));
print_hash("\tComputed message digest", "", mdbuf, EVP_MD_size(md)); print_hash("\tComputed message digest", "", mdbuf, EVP_MD_size(md));
@ -2630,7 +2630,7 @@ static int pkcs7_set_nested_signature(PKCS7 *p7, PKCS7 *p7nest, time_t time)
if (!si) if (!si)
return 0; /* FAILED */ return 0; /* FAILED */
if (((len = i2d_PKCS7(p7nest, NULL)) <= 0) || if (((len = i2d_PKCS7(p7nest, NULL)) <= 0) ||
(p = OPENSSL_malloc(len)) == NULL) (p = OPENSSL_malloc((size_t)len)) == NULL)
return 0; /* FAILED */ return 0; /* FAILED */
i2d_PKCS7(p7nest, &p); i2d_PKCS7(p7nest, &p);
p -= len; p -= len;
@ -2971,7 +2971,7 @@ static int msi_verify_header(char *indata, uint32_t filesize, MSI_PARAMS *msipar
} }
static int msi_verify_pkcs7(SIGNATURE *signature, MSI_FILE *msi, MSI_DIRENT *dirent, static int msi_verify_pkcs7(SIGNATURE *signature, MSI_FILE *msi, MSI_DIRENT *dirent,
char *exdata, uint32_t exlen, GLOBAL_OPTIONS *options) char *exdata, int exlen, GLOBAL_OPTIONS *options)
{ {
int ret = 1, mdok, mdtype = -1; int ret = 1, mdok, mdtype = -1;
u_char mdbuf[EVP_MAX_MD_SIZE]; u_char mdbuf[EVP_MAX_MD_SIZE];
@ -2987,7 +2987,7 @@ static int msi_verify_pkcs7(SIGNATURE *signature, MSI_FILE *msi, MSI_DIRENT *dir
if (idc) { if (idc) {
if (idc->messageDigest && idc->messageDigest->digest && idc->messageDigest->digestAlgorithm) { if (idc->messageDigest && idc->messageDigest->digest && idc->messageDigest->digestAlgorithm) {
mdtype = OBJ_obj2nid(idc->messageDigest->digestAlgorithm->algorithm); mdtype = OBJ_obj2nid(idc->messageDigest->digestAlgorithm->algorithm);
memcpy(mdbuf, idc->messageDigest->digest->data, idc->messageDigest->digest->length); memcpy(mdbuf, idc->messageDigest->digest->data, (size_t)idc->messageDigest->digest->length);
} }
SpcIndirectDataContent_free(idc); SpcIndirectDataContent_free(idc);
} }
@ -3007,7 +3007,7 @@ static int msi_verify_pkcs7(SIGNATURE *signature, MSI_FILE *msi, MSI_DIRENT *dir
BIO_push(hash, BIO_new(BIO_s_null())); BIO_push(hash, BIO_new(BIO_s_null()));
if (exdata) { if (exdata) {
BIO *prehash = BIO_new(BIO_f_md()); BIO *prehash = BIO_new(BIO_f_md());
if (EVP_MD_size(md) != (int)exlen) { if (EVP_MD_size(md) != exlen) {
printf("Incorrect MsiDigitalSignatureEx stream data length\n\n"); printf("Incorrect MsiDigitalSignatureEx stream data length\n\n");
BIO_free_all(hash); BIO_free_all(hash);
BIO_free_all(prehash); BIO_free_all(prehash);
@ -3042,7 +3042,7 @@ static int msi_verify_pkcs7(SIGNATURE *signature, MSI_FILE *msi, MSI_DIRENT *dir
print_hash("Current DigitalSignature ", "", mdbuf, EVP_MD_size(md)); print_hash("Current DigitalSignature ", "", mdbuf, EVP_MD_size(md));
BIO_gets(hash, (char*)cmdbuf, EVP_MAX_MD_SIZE); BIO_gets(hash, (char*)cmdbuf, EVP_MAX_MD_SIZE);
BIO_free_all(hash); BIO_free_all(hash);
mdok = !memcmp(mdbuf, cmdbuf, EVP_MD_size(md)); mdok = !memcmp(mdbuf, cmdbuf, (size_t)EVP_MD_size(md));
print_hash("Calculated DigitalSignature ", mdok ? "\n" : " MISMATCH!!!\n", cmdbuf, EVP_MD_size(md)); print_hash("Calculated DigitalSignature ", mdok ? "\n" : " MISMATCH!!!\n", cmdbuf, EVP_MD_size(md));
if (!mdok) { if (!mdok) {
printf("Signature verification: failed\n\n"); printf("Signature verification: failed\n\n");
@ -3073,7 +3073,7 @@ static int msi_verify_file(MSI_PARAMS *msiparams, GLOBAL_OPTIONS *options)
goto out; goto out;
} }
inlen = GET_UINT32_LE(ds->size); inlen = GET_UINT32_LE(ds->size);
indata = OPENSSL_malloc(inlen); indata = OPENSSL_malloc((size_t)inlen);
if (!msi_file_read(msiparams->msi, ds, 0, indata, inlen)) { if (!msi_file_read(msiparams->msi, ds, 0, indata, inlen)) {
printf("DigitalSignature stream data error\n\n"); printf("DigitalSignature stream data error\n\n");
goto out; goto out;
@ -3082,7 +3082,7 @@ static int msi_verify_file(MSI_PARAMS *msiparams, GLOBAL_OPTIONS *options)
printf("Warning: MsiDigitalSignatureEx stream doesn't exist\n"); printf("Warning: MsiDigitalSignatureEx stream doesn't exist\n");
} else { } else {
exlen = GET_UINT32_LE(dse->size); exlen = GET_UINT32_LE(dse->size);
exdata = OPENSSL_malloc(exlen); exdata = OPENSSL_malloc((size_t)exlen);
if (!msi_file_read(msiparams->msi, dse, 0, exdata, exlen)) { if (!msi_file_read(msiparams->msi, dse, 0, exdata, exlen)) {
printf("MsiDigitalSignatureEx stream data error\n\n"); printf("MsiDigitalSignatureEx stream data error\n\n");
goto out; goto out;
@ -3102,7 +3102,7 @@ static int msi_verify_file(MSI_PARAMS *msiparams, GLOBAL_OPTIONS *options)
for (i = 0; i < sk_SIGNATURE_num(signatures); i++) { for (i = 0; i < sk_SIGNATURE_num(signatures); i++) {
SIGNATURE *signature = sk_SIGNATURE_value(signatures, i); SIGNATURE *signature = sk_SIGNATURE_value(signatures, i);
printf("Signature Index: %d %s\n", i, i==0 ? " (Primary Signature)" : ""); printf("Signature Index: %d %s\n", i, i==0 ? " (Primary Signature)" : "");
ret &= msi_verify_pkcs7(signature, msiparams->msi, msiparams->dirent, exdata, exlen, options); ret &= msi_verify_pkcs7(signature, msiparams->msi, msiparams->dirent, exdata, (int)exlen, options);
} }
printf("Number of verified signatures: %d\n", i); printf("Number of verified signatures: %d\n", i);
out: out:
@ -3143,7 +3143,7 @@ static int msi_extract_file(MSI_PARAMS *msiparams, BIO *outdata, int output_pkcs
return 1; /* FAILED */ return 1; /* FAILED */
} }
len = GET_UINT32_LE(ds->size); len = GET_UINT32_LE(ds->size);
data = OPENSSL_malloc(len); data = OPENSSL_malloc((size_t)len);
(void)BIO_reset(outdata); (void)BIO_reset(outdata);
sig = msi_extract_existing_pkcs7(msiparams, ds, &data, len); sig = msi_extract_existing_pkcs7(msiparams, ds, &data, len);
if (!sig) { if (!sig) {
@ -3153,7 +3153,7 @@ static int msi_extract_file(MSI_PARAMS *msiparams, BIO *outdata, int output_pkcs
if (output_pkcs7) { if (output_pkcs7) {
ret = !PEM_write_bio_PKCS7(outdata, sig); ret = !PEM_write_bio_PKCS7(outdata, sig);
} else { } else {
ret = !BIO_write(outdata, data, len); ret = !BIO_write(outdata, data, (int)len);
} }
PKCS7_free(sig); PKCS7_free(sig);
OPENSSL_free(data); OPENSSL_free(data);
@ -3262,15 +3262,15 @@ static int pe_calc_digest(char *indata, int mdtype, u_char *mdbuf, FILE_HEADER *
goto err; goto err;
} }
memset(mdbuf, 0, EVP_MAX_MD_SIZE); memset(mdbuf, 0, EVP_MAX_MD_SIZE);
bio = BIO_new_mem_buf(indata, offset); bio = BIO_new_mem_buf(indata, (int)offset);
(void)BIO_seek(bio, 0); (void)BIO_seek(bio, 0);
bfb = OPENSSL_malloc(SIZE_16M); bfb = OPENSSL_malloc(SIZE_16M);
BIO_read(bio, bfb, header->header_size + 88); BIO_read(bio, bfb, (int)header->header_size + 88);
EVP_DigestUpdate(mdctx, bfb, header->header_size + 88); EVP_DigestUpdate(mdctx, bfb, header->header_size + 88);
BIO_read(bio, bfb, 4); BIO_read(bio, bfb, 4);
BIO_read(bio, bfb, 60 + header->pe32plus * 16); BIO_read(bio, bfb, 60 + (int)header->pe32plus * 16);
EVP_DigestUpdate(mdctx, bfb, 60 + header->pe32plus * 16); EVP_DigestUpdate(mdctx, bfb, 60 + header->pe32plus * 16);
BIO_read(bio, bfb, 8); BIO_read(bio, bfb, 8);
@ -3280,19 +3280,19 @@ static int pe_calc_digest(char *indata, int mdtype, u_char *mdbuf, FILE_HEADER *
uint32_t want = offset - n; uint32_t want = offset - n;
if (want > sizeof bfb) if (want > sizeof bfb)
want = sizeof bfb; want = sizeof bfb;
l = BIO_read(bio, bfb, want); l = BIO_read(bio, bfb, (int)want);
if (l <= 0) if (l <= 0)
break; break;
EVP_DigestUpdate(mdctx, bfb, l); EVP_DigestUpdate(mdctx, bfb, (size_t)l);
n += l; n += (uint32_t)l;
} }
if (!header->sigpos) { if (!header->sigpos) {
/* pad (with 0's) unsigned PE file to 8 byte boundary */ /* pad (with 0's) unsigned PE file to 8 byte boundary */
int len = 8 - header->fileend % 8; int len = 8 - header->fileend % 8;
if (len > 0 && len != 8) { if (len > 0 && len != 8) {
memset(bfb, 0, len); memset(bfb, 0, (size_t)len);
EVP_DigestUpdate(mdctx, bfb, len); EVP_DigestUpdate(mdctx, bfb, (size_t)len);
} }
} }
OPENSSL_free(bfb); OPENSSL_free(bfb);
@ -3360,8 +3360,8 @@ static int pe_extract_page_hash(SpcAttributeTypeAndOptionalValue *obj,
l = asn1_simple_hdr_len(obj->value->value.sequence->data + l2, obj->value->value.sequence->length - l2); l = asn1_simple_hdr_len(obj->value->value.sequence->data + l2, obj->value->value.sequence->length - l2);
l += l2; l += l2;
*phlen = obj->value->value.sequence->length - l; *phlen = obj->value->value.sequence->length - l;
*ph = OPENSSL_malloc(*phlen); *ph = OPENSSL_malloc((size_t)*phlen);
memcpy(*ph, obj->value->value.sequence->data + l, *phlen); memcpy(*ph, obj->value->value.sequence->data + l, (size_t)*phlen);
SpcAttributeTypeAndOptionalValue_free(obj); SpcAttributeTypeAndOptionalValue_free(obj);
return 1; /* OK */ return 1; /* OK */
} }
@ -3374,7 +3374,7 @@ static int pe_page_hash(char *indata, FILE_HEADER *header, u_char *ph, int phlen
printf("Page hash algorithm : %s\n", OBJ_nid2sn(phtype)); printf("Page hash algorithm : %s\n", OBJ_nid2sn(phtype));
print_hash("Page hash ", "...", ph, (phlen < 32) ? phlen : 32); print_hash("Page hash ", "...", ph, (phlen < 32) ? phlen : 32);
cph = pe_calc_page_hash(indata, header->header_size, header->pe32plus, header->sigpos, phtype, &cphlen); cph = pe_calc_page_hash(indata, header->header_size, header->pe32plus, header->sigpos, phtype, &cphlen);
mdok = (phlen == cphlen) && !memcmp(ph, cph, phlen); mdok = (phlen == cphlen) && !memcmp(ph, cph, (size_t)phlen);
print_hash("Calculated page hash ", mdok ? "...\n" : "... MISMATCH!!!\n", cph, (cphlen < 32) ? cphlen : 32); print_hash("Calculated page hash ", mdok ? "...\n" : "... MISMATCH!!!\n", cph, (cphlen < 32) ? cphlen : 32);
OPENSSL_free(cph); OPENSSL_free(cph);
return mdok; return mdok;
@ -3401,7 +3401,7 @@ static int pe_verify_pkcs7(SIGNATURE *signature, char *indata, FILE_HEADER *head
} }
if (idc->messageDigest && idc->messageDigest->digest && idc->messageDigest->digestAlgorithm) { if (idc->messageDigest && idc->messageDigest->digest && idc->messageDigest->digestAlgorithm) {
mdtype = OBJ_obj2nid(idc->messageDigest->digestAlgorithm->algorithm); mdtype = OBJ_obj2nid(idc->messageDigest->digestAlgorithm->algorithm);
memcpy(mdbuf, idc->messageDigest->digest->data, idc->messageDigest->digest->length); memcpy(mdbuf, idc->messageDigest->digest->data, (size_t)idc->messageDigest->digest->length);
} }
SpcIndirectDataContent_free(idc); SpcIndirectDataContent_free(idc);
} }
@ -3468,7 +3468,7 @@ static int pe_verify_file(char *indata, FILE_HEADER *header, GLOBAL_OPTIONS *opt
/* check PE checksum */ /* check PE checksum */
printf("Current PE checksum : %08X\n", header->pe_checksum); printf("Current PE checksum : %08X\n", header->pe_checksum);
bio = BIO_new_mem_buf(indata, header->fileend); bio = BIO_new_mem_buf(indata, (int)header->fileend);
real_pe_checksum = pe_calc_checksum(bio, header); real_pe_checksum = pe_calc_checksum(bio, header);
BIO_free(bio); BIO_free(bio);
if (header->pe_checksum && header->pe_checksum != real_pe_checksum) if (header->pe_checksum && header->pe_checksum != real_pe_checksum)
@ -3519,7 +3519,7 @@ static int pe_extract_file(char *indata, FILE_HEADER *header, BIO *outdata, int
ret = !PEM_write_bio_PKCS7(outdata, sig); ret = !PEM_write_bio_PKCS7(outdata, sig);
PKCS7_free(sig); PKCS7_free(sig);
} else } else
ret = !BIO_write(outdata, indata + header->sigpos, header->siglen); ret = !BIO_write(outdata, indata + header->sigpos, (int)header->siglen);
return ret; return ret;
} }
@ -3590,24 +3590,24 @@ static void pe_modify_header(char *indata, FILE_HEADER *header, BIO *hash, BIO *
int len = 0, i; int len = 0, i;
char *buf = OPENSSL_malloc(SIZE_64K); char *buf = OPENSSL_malloc(SIZE_64K);
i = header->header_size + 88; i = (int)header->header_size + 88;
BIO_write(hash, indata, i); BIO_write(hash, indata, i);
memset(buf, 0, 4); memset(buf, 0, 4);
BIO_write(outdata, buf, 4); /* zero out checksum */ BIO_write(outdata, buf, 4); /* zero out checksum */
i += 4; i += 4;
BIO_write(hash, indata + i, 60 + header->pe32plus * 16); BIO_write(hash, indata + i, 60 + (int)header->pe32plus * 16);
i += 60 + header->pe32plus * 16; i += 60 + (int)header->pe32plus * 16;
memset(buf, 0, 8); memset(buf, 0, 8);
BIO_write(outdata, buf, 8); /* zero out sigtable offset + pos */ BIO_write(outdata, buf, 8); /* zero out sigtable offset + pos */
i += 8; i += 8;
BIO_write(hash, indata + i, header->fileend - i); BIO_write(hash, indata + i, (int)header->fileend - i);
/* pad (with 0's) pe file to 8 byte boundary */ /* pad (with 0's) pe file to 8 byte boundary */
len = 8 - header->fileend % 8; len = 8 - header->fileend % 8;
if (len > 0 && len != 8) { if (len > 0 && len != 8) {
memset(buf, 0, len); memset(buf, 0, (size_t)len);
BIO_write(hash, buf, len); BIO_write(hash, buf, len);
header->fileend += len; header->fileend += (uint32_t)len;
} }
OPENSSL_free(buf); OPENSSL_free(buf);
} }
@ -3701,7 +3701,7 @@ static int cab_calc_digest(char *indata, int mdtype, u_char *mdbuf, FILE_HEADER
printf("Unable to set up the digest context\n"); printf("Unable to set up the digest context\n");
goto err; goto err;
} }
bio = BIO_new_mem_buf(indata, offset); bio = BIO_new_mem_buf(indata, (int)offset);
memset(mdbuf, 0, EVP_MAX_MD_SIZE); memset(mdbuf, 0, EVP_MAX_MD_SIZE);
(void)BIO_seek(bio, 0); (void)BIO_seek(bio, 0);
@ -3807,11 +3807,11 @@ static int cab_calc_digest(char *indata, int mdtype, u_char *mdbuf, FILE_HEADER
uint32_t want = offset - coffFiles; uint32_t want = offset - coffFiles;
if (want > sizeof bfb) if (want > sizeof bfb)
want = sizeof bfb; want = sizeof bfb;
l = BIO_read(bio, bfb, want); l = BIO_read(bio, bfb, (int)want);
if (l <= 0) if (l <= 0)
break; break;
EVP_DigestUpdate(mdctx, bfb, l); EVP_DigestUpdate(mdctx, bfb, (size_t)l);
coffFiles += l; coffFiles += (uint32_t)l;
} }
OPENSSL_free(bfb); OPENSSL_free(bfb);
BIO_free(bio); BIO_free(bio);
@ -3836,7 +3836,7 @@ static int cab_verify_pkcs7(SIGNATURE *signature, char *indata, FILE_HEADER *hea
if (idc) { if (idc) {
if (idc->messageDigest && idc->messageDigest->digest && idc->messageDigest->digestAlgorithm) { if (idc->messageDigest && idc->messageDigest->digest && idc->messageDigest->digestAlgorithm) {
mdtype = OBJ_obj2nid(idc->messageDigest->digestAlgorithm->algorithm); mdtype = OBJ_obj2nid(idc->messageDigest->digestAlgorithm->algorithm);
memcpy(mdbuf, idc->messageDigest->digest->data, idc->messageDigest->digest->length); memcpy(mdbuf, idc->messageDigest->digest->data, (size_t)idc->messageDigest->digest->length);
} }
SpcIndirectDataContent_free(idc); SpcIndirectDataContent_free(idc);
} }
@ -3921,7 +3921,7 @@ static int cab_extract_file(char *indata, FILE_HEADER *header, BIO *outdata, int
ret = !PEM_write_bio_PKCS7(outdata, sig); ret = !PEM_write_bio_PKCS7(outdata, sig);
PKCS7_free(sig); PKCS7_free(sig);
} else } else
ret = !BIO_write(outdata, indata + header->sigpos, header->siglen); ret = !BIO_write(outdata, indata + header->sigpos, (int)header->siglen);
return ret; return ret;
} }
@ -4023,7 +4023,7 @@ static int cab_remove_file(char *indata, FILE_HEADER *header, uint32_t filesize,
nfolders--; nfolders--;
} }
/* Write what's left - the compressed data bytes */ /* Write what's left - the compressed data bytes */
BIO_write(outdata, indata + i, filesize - header->siglen - i); BIO_write(outdata, indata + i, (int)(filesize - header->siglen) - i);
OPENSSL_free(buf); OPENSSL_free(buf);
return 0; /* OK */ return 0; /* OK */
@ -4033,7 +4033,7 @@ static void cab_modify_header(char *indata, FILE_HEADER *header, BIO *hash, BIO
{ {
int i; int i;
uint16_t nfolders, flags; uint16_t nfolders, flags;
const char buf[] = {0x00, 0x00}; u_char buf[] = {0x00, 0x00};
/* u1 signature[4] 4643534D MSCF: 0-3 */ /* u1 signature[4] 4643534D MSCF: 0-3 */
BIO_write(hash, indata, 4); BIO_write(hash, indata, 4);
@ -4082,7 +4082,7 @@ static void cab_modify_header(char *indata, FILE_HEADER *header, BIO *hash, BIO
nfolders--; nfolders--;
} }
/* Write what's left - the compressed data bytes */ /* Write what's left - the compressed data bytes */
BIO_write(hash, indata + i, header->sigpos - i); BIO_write(hash, indata + i, (int)header->sigpos - i);
} }
static void cab_add_header(char *indata, FILE_HEADER *header, BIO *hash, BIO *outdata) static void cab_add_header(char *indata, FILE_HEADER *header, BIO *hash, BIO *outdata)
@ -4149,7 +4149,7 @@ static void cab_add_header(char *indata, FILE_HEADER *header, BIO *hash, BIO *ou
nfolders--; nfolders--;
} }
/* Write what's left - the compressed data bytes */ /* Write what's left - the compressed data bytes */
BIO_write(hash, indata + i, header->fileend - i); BIO_write(hash, indata + i, (int)header->fileend - i);
OPENSSL_free(buf); OPENSSL_free(buf);
} }
@ -4238,7 +4238,7 @@ static int cat_verify_member(CatalogAuthAttr *attribute, char *indata, FILE_HEAD
if (idc->messageDigest && idc->messageDigest->digest && idc->messageDigest->digestAlgorithm) { if (idc->messageDigest && idc->messageDigest->digest && idc->messageDigest->digestAlgorithm) {
/* get a digest algorithm a message digest of the file from the content */ /* get a digest algorithm a message digest of the file from the content */
mdtype = OBJ_obj2nid(idc->messageDigest->digestAlgorithm->algorithm); mdtype = OBJ_obj2nid(idc->messageDigest->digestAlgorithm->algorithm);
memcpy(mdbuf, idc->messageDigest->digest->data, idc->messageDigest->digest->length); memcpy(mdbuf, idc->messageDigest->digest->data, (size_t)idc->messageDigest->digest->length);
} }
SpcIndirectDataContent_free(idc); SpcIndirectDataContent_free(idc);
} }
@ -4265,7 +4265,7 @@ static int cat_verify_member(CatalogAuthAttr *attribute, char *indata, FILE_HEAD
break; break;
} }
mdlen = EVP_MD_size(EVP_get_digestbynid(mdtype)); mdlen = EVP_MD_size(EVP_get_digestbynid(mdtype));
if (!memcmp(mdbuf, cmdbuf, mdlen)) { if (!memcmp(mdbuf, cmdbuf, (size_t)mdlen)) {
printf("Message digest algorithm : %s\n", OBJ_nid2sn(mdtype)); printf("Message digest algorithm : %s\n", OBJ_nid2sn(mdtype));
print_hash("Current message digest ", "", mdbuf, mdlen); print_hash("Current message digest ", "", mdbuf, mdlen);
print_hash("Calculated message digest ", "\n", cmdbuf, mdlen); print_hash("Calculated message digest ", "\n", cmdbuf, mdlen);
@ -4415,7 +4415,7 @@ static int add_opus_attribute(PKCS7_SIGNER_INFO *si, char *desc, char *url)
u_char *p = NULL; u_char *p = NULL;
opus = createOpus(desc, url); opus = createOpus(desc, url);
if ((len = i2d_SpcSpOpusInfo(opus, NULL)) <= 0 || (p = OPENSSL_malloc(len)) == NULL) { if ((len = i2d_SpcSpOpusInfo(opus, NULL)) <= 0 || (p = OPENSSL_malloc((size_t)len)) == NULL) {
SpcSpOpusInfo_free(opus); SpcSpOpusInfo_free(opus);
return 0; /* FAILED */ return 0; /* FAILED */
} }
@ -4527,9 +4527,9 @@ static int add_unauthenticated_blob(PKCS7 *sig)
si = sk_PKCS7_SIGNER_INFO_value(sig->d.sign->signer_info, 0); si = sk_PKCS7_SIGNER_INFO_value(sig->d.sign->signer_info, 0);
if (!si) if (!si)
return 0; /* FAILED */ return 0; /* FAILED */
if ((p = OPENSSL_malloc(len)) == NULL) if ((p = OPENSSL_malloc((size_t)len)) == NULL)
return 0; /* FAILED */ return 0; /* FAILED */
memset(p, 0, len); memset(p, 0, (size_t)len);
memcpy(p, prefix, sizeof prefix); memcpy(p, prefix, sizeof prefix);
memcpy(p + len - sizeof postfix, postfix, sizeof postfix); memcpy(p + len - sizeof postfix, postfix, sizeof postfix);
astr = ASN1_STRING_new(); astr = ASN1_STRING_new();
@ -4549,7 +4549,7 @@ static int append_signature(PKCS7 *sig, PKCS7 *cursig, file_type_t type,
{ {
u_char *p = NULL; u_char *p = NULL;
PKCS7 *outsig = NULL; PKCS7 *outsig = NULL;
const char buf[] = { u_char buf[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}; };
@ -4567,7 +4567,7 @@ static int append_signature(PKCS7 *sig, PKCS7 *cursig, file_type_t type,
outsig = sig; outsig = sig;
} }
/* Append signature to outfile */ /* Append signature to outfile */
if (((*len = i2d_PKCS7(outsig, NULL)) <= 0) || (p = OPENSSL_malloc(*len)) == NULL) { if (((*len = i2d_PKCS7(outsig, NULL)) <= 0) || (p = OPENSSL_malloc((size_t)*len)) == NULL) {
printf("i2d_PKCS memory allocation failed: %d\n", *len); printf("i2d_PKCS memory allocation failed: %d\n", *len);
return 1; /* FAILED */ return 1; /* FAILED */
} }
@ -4585,15 +4585,15 @@ static int append_signature(PKCS7 *sig, PKCS7 *cursig, file_type_t type,
BIO_write(outdata, p, *len); BIO_write(outdata, p, *len);
/* pad (with 0's) asn1 blob to 8 byte boundary */ /* pad (with 0's) asn1 blob to 8 byte boundary */
if (*padlen > 0) { if (*padlen > 0) {
memset(p, 0, *padlen); memset(p, 0, (size_t)*padlen);
BIO_write(outdata, p, *padlen); BIO_write(outdata, p, *padlen);
} }
} else if (type == FILE_TYPE_MSI) { } else if (type == FILE_TYPE_MSI) {
int len_msi = *len; int len_msi = *len;
u_char *p_msi = OPENSSL_malloc(len_msi); u_char *p_msi = OPENSSL_malloc((size_t)len_msi);
memcpy(p_msi, p, len_msi); memcpy(p_msi, p, (size_t)len_msi);
if (!msi_file_write(msiparams->msi, msiparams->dirent, p_msi, len_msi, if (!msi_file_write(msiparams->msi, msiparams->dirent, p_msi, (uint32_t)len_msi,
msiparams->p_msiex, msiparams->len_msiex, outdata)) { msiparams->p_msiex, (uint32_t)msiparams->len_msiex, outdata)) {
printf("Saving the msi file failed\n"); printf("Saving the msi file failed\n");
return 1; /* FAILED */ return 1; /* FAILED */
} }
@ -4607,7 +4607,7 @@ static int append_signature(PKCS7 *sig, PKCS7 *cursig, file_type_t type,
static void update_data_size(file_type_t type, cmd_type_t cmd, FILE_HEADER *header, static void update_data_size(file_type_t type, cmd_type_t cmd, FILE_HEADER *header,
int padlen, int len, BIO *outdata) int padlen, int len, BIO *outdata)
{ {
const char buf[] = { u_char buf[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}; };
@ -4652,7 +4652,7 @@ static STACK_OF(X509) *PEM_read_certs(BIO *bin, char *certpass)
return certs; return certs;
} }
static off_t get_file_size(const char *infile) static uint32_t get_file_size(const char *infile)
{ {
int ret; int ret;
#ifdef _WIN32 #ifdef _WIN32
@ -4671,10 +4671,10 @@ static off_t get_file_size(const char *infile)
printf("Unrecognized file type - file is too short: %s\n", infile); printf("Unrecognized file type - file is too short: %s\n", infile);
return 0; return 0;
} }
return st.st_size; return (uint32_t)st.st_size;
} }
static char *map_file(const char *infile, const off_t size) static char *map_file(const char *infile, const size_t size)
{ {
char *indata = NULL; char *indata = NULL;
#ifdef WIN32 #ifdef WIN32
@ -4860,7 +4860,7 @@ static char *getpassword(const char *prompt)
tcgetattr(fileno(stdin), &ofl); tcgetattr(fileno(stdin), &ofl);
nfl = ofl; nfl = ofl;
nfl.c_lflag &= ~ECHO; nfl.c_lflag &= ~(unsigned int)ECHO;
nfl.c_lflag |= ECHONL; nfl.c_lflag |= ECHONL;
if (tcsetattr(fileno(stdin), TCSANOW, &nfl) != 0) { if (tcsetattr(fileno(stdin), TCSANOW, &nfl) != 0) {
@ -4915,7 +4915,7 @@ static int read_password(GLOBAL_OPTIONS *options)
if (passfd < 0) { if (passfd < 0) {
return 0; /* FAILED */ return 0; /* FAILED */
} }
passlen = read(passfd, passbuf, sizeof passbuf - 1); passlen = (int)read(passfd, passbuf, sizeof passbuf - 1);
close(passfd); close(passfd);
#endif /* WIN32 */ #endif /* WIN32 */
if (passlen <= 0) { if (passlen <= 0) {
@ -4930,7 +4930,7 @@ static int read_password(GLOBAL_OPTIONS *options)
} else { } else {
options->pass = OPENSSL_strdup(passbuf); options->pass = OPENSSL_strdup(passbuf);
} }
memset(passbuf, 0, sizeof(passbuf)); memset(passbuf, 0, sizeof passbuf);
#ifdef PROVIDE_ASKPASS #ifdef PROVIDE_ASKPASS
} else if (options->askpass) { } else if (options->askpass) {
options->pass = getpassword("Password: "); options->pass = getpassword("Password: ");
@ -5364,7 +5364,7 @@ static PKCS7 *get_sigfile(char *sigfile, file_type_t type)
return NULL; /* FAILED */ return NULL; /* FAILED */
} }
if (sigfilesize >= sizeof pemhdr && !memcmp(insigdata, pemhdr, sizeof pemhdr - 1)) { if (sigfilesize >= sizeof pemhdr && !memcmp(insigdata, pemhdr, sizeof pemhdr - 1)) {
sigbio = BIO_new_mem_buf(insigdata, sigfilesize); sigbio = BIO_new_mem_buf(insigdata, (int)sigfilesize);
sig = PEM_read_bio_PKCS7(sigbio, NULL, NULL, NULL); sig = PEM_read_bio_PKCS7(sigbio, NULL, NULL, NULL);
BIO_free_all(sigbio); BIO_free_all(sigbio);
} else { } else {
@ -5479,7 +5479,7 @@ static PKCS7 *msi_presign_file(file_type_t type, cmd_type_t cmd, FILE_HEADER *he
return NULL; /* FAILED */ return NULL; /* FAILED */
} }
len = GET_UINT32_LE(ds->size); len = GET_UINT32_LE(ds->size);
data = OPENSSL_malloc(len); data = OPENSSL_malloc((size_t)len);
*cursig = msi_extract_existing_pkcs7(msiparams, ds, &data, len); *cursig = msi_extract_existing_pkcs7(msiparams, ds, &data, len);
OPENSSL_free(data); OPENSSL_free(data);
if (!*cursig) { if (!*cursig) {