mirror of
https://github.com/mtrojnar/osslsigncode.git
synced 2025-04-05 01:00:11 -05:00
Squash -Wcast-qual and -Wconversion warnings
This commit is contained in:
olszomal
Michał Trojnara
parent
f42459ff09
commit
1d0918c84d
107
msi.c
107
msi.c
@ -691,7 +691,7 @@ int msi_hash_dir(MSI_FILE *msi, MSI_DIRENT *dirent, BIO *hash, int is_root)
|
||||
OPENSSL_free(indata);
|
||||
goto out;
|
||||
}
|
||||
BIO_write(hash, indata, inlen);
|
||||
BIO_write(hash, indata, (int)inlen);
|
||||
OPENSSL_free(indata);
|
||||
}
|
||||
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;
|
||||
int ret = 0;
|
||||
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();
|
||||
|
||||
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;
|
||||
if (want > sizeof bfb)
|
||||
want = sizeof bfb;
|
||||
l = BIO_read(bio, bfb, want);
|
||||
l = BIO_read(bio, bfb, (int)want);
|
||||
if (l <= 0)
|
||||
break;
|
||||
EVP_DigestUpdate(mdctx, bfb, l);
|
||||
n += l;
|
||||
EVP_DigestUpdate(mdctx, bfb, (size_t)l);
|
||||
n += (uint32_t)l;
|
||||
}
|
||||
EVP_DigestFinal(mdctx, mdbuf, NULL);
|
||||
ret = 1; /* OK */
|
||||
@ -745,34 +745,34 @@ out:
|
||||
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;
|
||||
if (out->miniStreamLen + len >= out->ministreamsMemallocCount * out->sectorSize) {
|
||||
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;
|
||||
}
|
||||
|
||||
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) {
|
||||
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;
|
||||
}
|
||||
|
||||
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) {
|
||||
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;
|
||||
}
|
||||
|
||||
@ -837,7 +837,7 @@ static int dirent_insert(MSI_DIRENT *dirent, const u_char *name, uint16_t nameLe
|
||||
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 (!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 */
|
||||
}
|
||||
|
||||
static int stream_read(MSI_FILE *msi, MSI_ENTRY *entry, u_char *p_msi, int len_msi,
|
||||
u_char *p_msiex, int len_msiex, char **indata, int inlen, int is_root)
|
||||
static uint32_t stream_read(MSI_FILE *msi, MSI_ENTRY *entry, u_char *p_msi, uint32_t len_msi,
|
||||
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)) {
|
||||
*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 */
|
||||
static int stream_handle(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p_msi, int len_msi,
|
||||
u_char *p_msiex, int len_msiex, BIO *outdata, MSI_OUT *out, int is_root)
|
||||
static int stream_handle(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p_msi, uint32_t len_msi,
|
||||
u_char *p_msiex, uint32_t len_msiex, BIO *outdata, MSI_OUT *out, int is_root)
|
||||
{
|
||||
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);
|
||||
/* fill to the end with known data, such as all zeroes */
|
||||
if (inlen % msi->m_minisectorSize > 0) {
|
||||
int remain = msi->m_minisectorSize - inlen % msi->m_minisectorSize;
|
||||
memset(buf, 0, remain);
|
||||
uint32_t remain = msi->m_minisectorSize - inlen % msi->m_minisectorSize;
|
||||
memset(buf, 0, (size_t)remain);
|
||||
ministream_append(out, buf, remain);
|
||||
}
|
||||
while (inlen > msi->m_minisectorSize) {
|
||||
out->miniSectorNum += 1;
|
||||
PUT_UINT32_LE(out->miniSectorNum, buf);
|
||||
minifat_append(out, buf, 4);
|
||||
inlen -= (uint32_t)msi->m_minisectorSize;
|
||||
inlen -= msi->m_minisectorSize;
|
||||
}
|
||||
PUT_UINT32_LE(ENDOFCHAIN, buf);
|
||||
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 */
|
||||
child->entry->startSectorLocation = out->sectorNum;
|
||||
/* stream save */
|
||||
BIO_write(outdata, indata, inlen);
|
||||
BIO_write(outdata, indata, (int)inlen);
|
||||
/* fill to the end with known data, such as all zeroes */
|
||||
if (inlen % out->sectorSize > 0) {
|
||||
int remain = out->sectorSize - inlen % out->sectorSize;
|
||||
memset(buf, 0, remain);
|
||||
BIO_write(outdata, buf, remain);
|
||||
uint32_t remain = out->sectorSize - inlen % out->sectorSize;
|
||||
memset(buf, 0, (size_t)remain);
|
||||
BIO_write(outdata, buf, (int)remain);
|
||||
}
|
||||
/* set a sector chain in the FAT */
|
||||
while (inlen > out->sectorSize) {
|
||||
out->sectorNum += 1;
|
||||
PUT_UINT32_LE(out->sectorNum, buf);
|
||||
fat_append(out, buf, 4);
|
||||
inlen -= (uint32_t)out->sectorSize;
|
||||
inlen -= out->sectorSize;
|
||||
}
|
||||
PUT_UINT32_LE(ENDOFCHAIN, buf);
|
||||
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)
|
||||
{
|
||||
char buf[MAX_SECTOR_SIZE];
|
||||
int remain, i;
|
||||
int ministreamSectorsCount = (out->miniStreamLen + out->sectorSize - 1) / out->sectorSize;
|
||||
uint32_t i, remain;
|
||||
uint32_t ministreamSectorsCount = (out->miniStreamLen + out->sectorSize - 1) / out->sectorSize;
|
||||
|
||||
/* set the first sector of the mini stream in the entry root object */
|
||||
dirent->entry->startSectorLocation = out->sectorNum;
|
||||
/* ministream save */
|
||||
BIO_write(outdata, out->ministream, out->miniStreamLen);
|
||||
BIO_write(outdata, out->ministream, (int)out->miniStreamLen);
|
||||
OPENSSL_free(out->ministream);
|
||||
/* fill to the end with known data, such as all zeroes */
|
||||
if (out->miniStreamLen % out->sectorSize > 0) {
|
||||
remain = out->sectorSize - out->miniStreamLen % out->sectorSize;
|
||||
memset(buf, 0, remain);
|
||||
BIO_write(outdata, buf, remain);
|
||||
memset(buf, 0, (size_t)remain);
|
||||
BIO_write(outdata, buf, (int)remain);
|
||||
}
|
||||
/* set a sector chain in the FAT */
|
||||
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)
|
||||
{
|
||||
char buf[MAX_SECTOR_SIZE];
|
||||
int i,remain;
|
||||
uint32_t i, remain;
|
||||
|
||||
/* set Mini FAT Starting Sector Location in the header */
|
||||
if (out->minifatLen == 0) {
|
||||
@ -995,7 +995,7 @@ static void minifat_save(BIO *outdata, MSI_OUT *out)
|
||||
PUT_UINT32_LE(out->sectorNum, buf);
|
||||
memcpy(out->header + HEADER_MINI_FAT_SECTOR_LOC, buf, 4);
|
||||
/* minifat save */
|
||||
BIO_write(outdata, out->minifat, out->minifatLen);
|
||||
BIO_write(outdata, out->minifat, (int)out->minifatLen);
|
||||
/* marks the end of the stream */
|
||||
PUT_UINT32_LE(ENDOFCHAIN, buf);
|
||||
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 */
|
||||
if (out->minifatLen % out->sectorSize > 0) {
|
||||
remain = out->sectorSize - out->minifatLen % out->sectorSize;
|
||||
memset(buf, FREESECT, remain);
|
||||
BIO_write(outdata, buf, remain);
|
||||
memset(buf, (int)FREESECT, (size_t)remain);
|
||||
BIO_write(outdata, buf, (int)remain);
|
||||
}
|
||||
/* set a sector chain in the FAT */
|
||||
out->minifatSectorsCount = (out->minifatLen + out->sectorSize - 1) / out->sectorSize;
|
||||
@ -1059,13 +1059,13 @@ static char *msi_unused_dirent_get()
|
||||
/* initialise 127 bytes */
|
||||
memset(data, 0, DIRENT_SIZE);
|
||||
|
||||
memset(data + DIRENT_LEFT_SIBLING_ID, NOSTREAM, 4);
|
||||
memset(data + DIRENT_RIGHT_SIBLING_ID, NOSTREAM, 4);
|
||||
memset(data + DIRENT_CHILD_ID, NOSTREAM, 4);
|
||||
memset(data + DIRENT_LEFT_SIBLING_ID, (int)NOSTREAM, 4);
|
||||
memset(data + DIRENT_RIGHT_SIBLING_ID, (int)NOSTREAM, 4);
|
||||
memset(data + DIRENT_CHILD_ID, (int)NOSTREAM, 4);
|
||||
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;
|
||||
char *entry;
|
||||
@ -1083,7 +1083,7 @@ static int dirents_save(MSI_DIRENT *dirent, BIO *outdata, MSI_OUT *out, int *str
|
||||
} else {
|
||||
/* make linked list rather than tree, only use next - right sibling */
|
||||
count += childenNum;
|
||||
dirent->entry->rightSiblingID = *streamId + count + 1;
|
||||
dirent->entry->rightSiblingID = *streamId + (uint32_t)count + 1;
|
||||
}
|
||||
} else { /* DIR_ROOT */
|
||||
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 *unused_entry;
|
||||
int i, remain;
|
||||
int streamId = 0;
|
||||
uint32_t i, remain, streamId = 0;
|
||||
|
||||
/* set Directory Starting Sector Location in the header */
|
||||
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)
|
||||
{
|
||||
char buf[MAX_SECTOR_SIZE];
|
||||
int i, remain;
|
||||
uint32_t i, remain;
|
||||
|
||||
remain = (out->fatLen + 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 */
|
||||
if (out->fatLen % out->sectorSize > 0) {
|
||||
remain = out->sectorSize - out->fatLen % out->sectorSize;
|
||||
memset(buf, FREESECT, remain);
|
||||
memset(buf, (int)FREESECT, (size_t)remain);
|
||||
fat_append(out, buf, remain);
|
||||
}
|
||||
BIO_write(outdata, out->fat, out->fatLen);
|
||||
BIO_write(outdata, out->fat, (int)out->fatLen);
|
||||
return 1; /* OK */
|
||||
}
|
||||
|
||||
static void header_save(BIO *outdata, MSI_OUT *out)
|
||||
{
|
||||
char buf[MAX_SECTOR_SIZE];
|
||||
int remain;
|
||||
uint32_t remain;
|
||||
|
||||
/* set Number of FAT sectors in the header */
|
||||
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);
|
||||
|
||||
remain = out->sectorSize - HEADER_SIZE;
|
||||
memset(buf, 0, remain);
|
||||
BIO_write(outdata, buf, remain);
|
||||
memset(buf, 0, (size_t)remain);
|
||||
BIO_write(outdata, buf, (int)remain);
|
||||
}
|
||||
|
||||
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 */
|
||||
memcpy(data + HEADER_DIFAT, dead_food, 4); /* sector number for FAT */
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
@ -1306,8 +1305,8 @@ static int msiout_set(MSI_FILE *msi, int len_msi, int len_msiex, MSI_OUT *out)
|
||||
return 1; /* OK */
|
||||
}
|
||||
|
||||
int msi_file_write(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p_msi, int len_msi,
|
||||
u_char *p_msiex, int len_msiex, BIO *outdata)
|
||||
int msi_file_write(MSI_FILE *msi, MSI_DIRENT *dirent, u_char *p_msi, uint32_t len_msi,
|
||||
u_char *p_msiex, uint32_t len_msiex, BIO *outdata)
|
||||
{
|
||||
MSI_OUT out;
|
||||
int ret = 0;
|
||||
|
||||
47
msi.h
47
msi.h
@ -72,25 +72,25 @@
|
||||
#define DIRENT_START_SECTOR_LOC 0x74
|
||||
#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) | \
|
||||
(((u_char*)(p))[2]<<16) | (((u_char*)(p))[3]<<24))
|
||||
#define GET_UINT32_LE(p) (uint32_t)(((const u_char *)(p))[0] | \
|
||||
(((const u_char *)(p))[1] << 8) | \
|
||||
(((const u_char *)(p))[2] << 16) | \
|
||||
(((const u_char *)(p))[3] << 24))
|
||||
|
||||
#define PUT_UINT8_LE(i,p) \
|
||||
((u_char*)(p))[0] = (i) & 0xff;
|
||||
#define PUT_UINT8_LE(i, p) ((u_char *)(p))[0] = (u_char)((i) & 0xff);
|
||||
|
||||
#define PUT_UINT16_LE(i,p) \
|
||||
((u_char*)(p))[0] = (i) & 0xff; \
|
||||
((u_char*)(p))[1] = ((i)>>8) & 0xff
|
||||
#define PUT_UINT16_LE(i,p) ((u_char *)(p))[0] = (u_char)((i) & 0xff); \
|
||||
((u_char *)(p))[1] = (u_char)(((i) >> 8) & 0xff)
|
||||
|
||||
#define PUT_UINT32_LE(i,p) \
|
||||
((u_char*)(p))[0] = (i) & 0xff; \
|
||||
((u_char*)(p))[1] = ((i)>>8) & 0xff; \
|
||||
((u_char*)(p))[2] = ((i)>>16) & 0xff; \
|
||||
((u_char*)(p))[3] = ((i)>>24) & 0xff
|
||||
#define PUT_UINT32_LE(i,p) ((u_char *)(p))[0] = (u_char)((i) & 0xff); \
|
||||
((u_char *)(p))[1] = (u_char)(((i) >> 8) & 0xff); \
|
||||
((u_char *)(p))[2] = (u_char)(((i) >> 16) & 0xff); \
|
||||
((u_char *)(p))[3] = (u_char)(((i) >> 24) & 0xff)
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE 0
|
||||
@ -171,14 +171,14 @@ typedef struct {
|
||||
uint32_t miniStreamLen;
|
||||
uint32_t minifatLen;
|
||||
uint32_t fatLen;
|
||||
int ministreamsMemallocCount;
|
||||
int minifatMemallocCount;
|
||||
int fatMemallocCount;
|
||||
int dirtreeSectorsCount;
|
||||
int minifatSectorsCount;
|
||||
int fatSectorsCount;
|
||||
int miniSectorNum;
|
||||
int sectorNum;
|
||||
uint32_t ministreamsMemallocCount;
|
||||
uint32_t minifatMemallocCount;
|
||||
uint32_t fatMemallocCount;
|
||||
uint32_t dirtreeSectorsCount;
|
||||
uint32_t minifatSectorsCount;
|
||||
uint32_t fatSectorsCount;
|
||||
uint32_t miniSectorNum;
|
||||
uint32_t sectorNum;
|
||||
uint32_t sectorSize;
|
||||
} 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_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_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:
|
||||
|
||||
190
osslsigncode.c
190
osslsigncode.c
@ -252,7 +252,7 @@ typedef struct {
|
||||
|
||||
typedef struct {
|
||||
uint32_t header_size;
|
||||
int pe32plus;
|
||||
uint32_t pe32plus;
|
||||
uint16_t magic;
|
||||
uint32_t pe_checksum;
|
||||
uint32_t nrvas;
|
||||
@ -469,7 +469,7 @@ IMPLEMENT_ASN1_FUNCTIONS(MsCtlContent)
|
||||
|
||||
|
||||
typedef struct {
|
||||
ASN1_BIT_STRING* flags;
|
||||
ASN1_BIT_STRING *flags;
|
||||
SpcLink *file;
|
||||
} 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)
|
||||
{
|
||||
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));
|
||||
print_hash("Current message digest ", "", mdbuf, 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
|
||||
*/
|
||||
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 (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");
|
||||
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_MD_CTX_free(mdctx);
|
||||
|
||||
@ -882,7 +882,7 @@ static BIO *encode_rfc3161_request(PKCS7 *sig, const EVP_MD *md)
|
||||
req->certReq = (void*)0x1;
|
||||
|
||||
len = i2d_TimeStampReq(req, NULL);
|
||||
p = OPENSSL_malloc(len);
|
||||
p = OPENSSL_malloc((size_t)len);
|
||||
len = i2d_TimeStampReq(req, &p);
|
||||
p -= len;
|
||||
TimeStampReq_free(req);
|
||||
@ -918,7 +918,7 @@ static BIO *encode_authenticode_request(PKCS7 *sig)
|
||||
req->blob->signature = si->enc_digest;
|
||||
|
||||
len = i2d_TimeStampRequest(req, NULL);
|
||||
p = OPENSSL_malloc(len);
|
||||
p = OPENSSL_malloc((size_t)len);
|
||||
len = i2d_TimeStampRequest(req, &p);
|
||||
p -= len;
|
||||
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
|
||||
* 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;
|
||||
STACK_OF(X509_ATTRIBUTE) *attrs;
|
||||
@ -968,7 +968,7 @@ static int decode_rfc3161_response(PKCS7 *sig, BIO *bin, int verbose)
|
||||
TimeStampResp_free(reply);
|
||||
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) {
|
||||
printf("Failed to convert pkcs7: %d\n", len);
|
||||
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
|
||||
* 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_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);
|
||||
if (!info)
|
||||
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) {
|
||||
printf("Failed to convert signer info: %d\n", len);
|
||||
ERR_print_errors_fp(stdout);
|
||||
@ -1065,7 +1065,7 @@ static int add_timestamp(PKCS7 *sig, char *url, char *proxy, int rfc3161,
|
||||
CURLcode res;
|
||||
BIO *bout, *bin;
|
||||
u_char *p = NULL;
|
||||
int len = 0;
|
||||
long len = 0;
|
||||
|
||||
if (!url)
|
||||
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,
|
||||
int pe32plus, uint32_t sigpos, int phtype, int *rphlen)
|
||||
uint32_t pe32plus, uint32_t sigpos, int phtype, int *rphlen)
|
||||
{
|
||||
uint16_t nsections, opthdr_size;
|
||||
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);
|
||||
hdrsize = GET_UINT32_LE(indata + header_size + 84);
|
||||
pphlen = 4 + EVP_MD_size(md);
|
||||
phlen = pphlen * (3 + nsections + sigpos / pagesize);
|
||||
phlen = pphlen * (3 + (int)nsections + (int)(sigpos / pagesize));
|
||||
|
||||
res = OPENSSL_malloc(phlen);
|
||||
zeroes = OPENSSL_zalloc(pagesize);
|
||||
res = OPENSSL_malloc((size_t)phlen);
|
||||
zeroes = OPENSSL_zalloc((size_t)pagesize);
|
||||
|
||||
EVP_DigestUpdate(mdctx, indata, header_size + 88);
|
||||
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);
|
||||
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++;
|
||||
OPENSSL_free(zeroes);
|
||||
*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();
|
||||
sk_ASN1_TYPE_push(oset, tostr);
|
||||
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);
|
||||
ASN1_TYPE_free(tostr);
|
||||
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);
|
||||
OPENSSL_free(p);
|
||||
l = i2d_SpcAttributeTypeAndOptionalValue(aval, NULL);
|
||||
tmp = p = OPENSSL_malloc(l);
|
||||
tmp = p = OPENSSL_malloc((size_t)l);
|
||||
i2d_SpcAttributeTypeAndOptionalValue(aval, &tmp);
|
||||
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();
|
||||
sk_ASN1_TYPE_push(aset, taval);
|
||||
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);
|
||||
ASN1_TYPE_free(taval);
|
||||
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) {
|
||||
SpcLink *link = get_obsolete_link();
|
||||
l = i2d_SpcLink(link, NULL);
|
||||
p = OPENSSL_malloc(l);
|
||||
p = OPENSSL_malloc((size_t)l);
|
||||
i2d_SpcLink(link, &p);
|
||||
p -= l;
|
||||
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();
|
||||
}
|
||||
l = i2d_SpcPeImageData(pid, NULL);
|
||||
p = OPENSSL_malloc(l);
|
||||
p = OPENSSL_malloc((size_t)l);
|
||||
i2d_SpcPeImageData(pid, &p);
|
||||
p -= l;
|
||||
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_OCTET_STRING_set(si->string, msistr, sizeof msistr);
|
||||
l = i2d_SpcSipInfo(si, NULL);
|
||||
p = OPENSSL_malloc(l);
|
||||
p = OPENSSL_malloc((size_t)l);
|
||||
i2d_SpcSipInfo(si, &p);
|
||||
p -= l;
|
||||
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;
|
||||
|
||||
hashlen = EVP_MD_size(options->md);
|
||||
hash = OPENSSL_malloc(hashlen);
|
||||
memset(hash, 0, hashlen);
|
||||
hash = OPENSSL_malloc((size_t)hashlen);
|
||||
memset(hash, 0, (size_t)hashlen);
|
||||
ASN1_OCTET_STRING_set(idc->messageDigest->digest, hash, hashlen);
|
||||
OPENSSL_free(hash);
|
||||
|
||||
*len = i2d_SpcIndirectDataContent(idc, NULL);
|
||||
*blob = OPENSSL_malloc(*len);
|
||||
*blob = OPENSSL_malloc((size_t)*len);
|
||||
p = *blob;
|
||||
i2d_SpcIndirectDataContent(idc, &p);
|
||||
SpcIndirectDataContent_free(idc);
|
||||
@ -1729,7 +1729,7 @@ static int set_signing_blob(PKCS7 *sig, BIO *hash, u_char *buf, int len)
|
||||
PKCS7 *td7;
|
||||
|
||||
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);
|
||||
|
||||
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))
|
||||
return 0; /* FAILED */
|
||||
memcpy(buf, p, len);
|
||||
memcpy(buf, p, (size_t)len);
|
||||
OPENSSL_free(p);
|
||||
if (!set_signing_blob(sig, hash, buf, len)) {
|
||||
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");
|
||||
goto out;
|
||||
}
|
||||
certlen = i2d_X509(leaf, NULL);
|
||||
certlen = (size_t)i2d_X509(leaf, NULL);
|
||||
certbuf = OPENSSL_malloc(certlen);
|
||||
tmp = certbuf;
|
||||
i2d_X509(leaf, &tmp);
|
||||
@ -1896,7 +1896,7 @@ static int verify_leaf_hash(X509 *leaf, const char *leafhash)
|
||||
EVP_MD_CTX_free(ctx);
|
||||
|
||||
/* 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));
|
||||
goto out;
|
||||
}
|
||||
@ -2238,7 +2238,7 @@ static CMS_ContentInfo *cms_get_timestamp(PKCS7_SIGNED *p7_signed, PKCS7_SIGNER_
|
||||
}
|
||||
|
||||
/* 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);
|
||||
goto out;
|
||||
}
|
||||
@ -2355,7 +2355,7 @@ static void get_signed_attributes(SIGNATURE *signature, STACK_OF(X509_ATTRIBUTE)
|
||||
u_char *desc;
|
||||
int len = ASN1_STRING_to_UTF8(&desc, opus->programName->value.unicode);
|
||||
if (len >= 0) {
|
||||
signature->desc = OPENSSL_strndup((char *)desc, len);
|
||||
signature->desc = OPENSSL_strndup((char *)desc, (size_t)len);
|
||||
OPENSSL_free(desc);
|
||||
}
|
||||
} 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");
|
||||
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_MD_CTX_free(mdctx);
|
||||
|
||||
/* compare the provided hash against the computed hash */
|
||||
hash = token->messageImprint->digest;
|
||||
/* 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",
|
||||
(md_nid == NID_undef) ? "UNKNOWN" : OBJ_nid2ln(md_nid));
|
||||
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)
|
||||
return 0; /* FAILED */
|
||||
if (((len = i2d_PKCS7(p7nest, NULL)) <= 0) ||
|
||||
(p = OPENSSL_malloc(len)) == NULL)
|
||||
(p = OPENSSL_malloc((size_t)len)) == NULL)
|
||||
return 0; /* FAILED */
|
||||
i2d_PKCS7(p7nest, &p);
|
||||
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,
|
||||
char *exdata, uint32_t exlen, GLOBAL_OPTIONS *options)
|
||||
char *exdata, int exlen, GLOBAL_OPTIONS *options)
|
||||
{
|
||||
int ret = 1, mdok, mdtype = -1;
|
||||
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->messageDigest && idc->messageDigest->digest && idc->messageDigest->digestAlgorithm) {
|
||||
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);
|
||||
}
|
||||
@ -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()));
|
||||
if (exdata) {
|
||||
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");
|
||||
BIO_free_all(hash);
|
||||
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));
|
||||
BIO_gets(hash, (char*)cmdbuf, EVP_MAX_MD_SIZE);
|
||||
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));
|
||||
if (!mdok) {
|
||||
printf("Signature verification: failed\n\n");
|
||||
@ -3073,7 +3073,7 @@ static int msi_verify_file(MSI_PARAMS *msiparams, GLOBAL_OPTIONS *options)
|
||||
goto out;
|
||||
}
|
||||
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)) {
|
||||
printf("DigitalSignature stream data error\n\n");
|
||||
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");
|
||||
} else {
|
||||
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)) {
|
||||
printf("MsiDigitalSignatureEx stream data error\n\n");
|
||||
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++) {
|
||||
SIGNATURE *signature = sk_SIGNATURE_value(signatures, i);
|
||||
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);
|
||||
out:
|
||||
@ -3143,7 +3143,7 @@ static int msi_extract_file(MSI_PARAMS *msiparams, BIO *outdata, int output_pkcs
|
||||
return 1; /* FAILED */
|
||||
}
|
||||
len = GET_UINT32_LE(ds->size);
|
||||
data = OPENSSL_malloc(len);
|
||||
data = OPENSSL_malloc((size_t)len);
|
||||
(void)BIO_reset(outdata);
|
||||
sig = msi_extract_existing_pkcs7(msiparams, ds, &data, len);
|
||||
if (!sig) {
|
||||
@ -3153,7 +3153,7 @@ static int msi_extract_file(MSI_PARAMS *msiparams, BIO *outdata, int output_pkcs
|
||||
if (output_pkcs7) {
|
||||
ret = !PEM_write_bio_PKCS7(outdata, sig);
|
||||
} else {
|
||||
ret = !BIO_write(outdata, data, len);
|
||||
ret = !BIO_write(outdata, data, (int)len);
|
||||
}
|
||||
PKCS7_free(sig);
|
||||
OPENSSL_free(data);
|
||||
@ -3262,15 +3262,15 @@ static int pe_calc_digest(char *indata, int mdtype, u_char *mdbuf, FILE_HEADER *
|
||||
goto err;
|
||||
}
|
||||
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);
|
||||
|
||||
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);
|
||||
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);
|
||||
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;
|
||||
if (want > sizeof bfb)
|
||||
want = sizeof bfb;
|
||||
l = BIO_read(bio, bfb, want);
|
||||
l = BIO_read(bio, bfb, (int)want);
|
||||
if (l <= 0)
|
||||
break;
|
||||
EVP_DigestUpdate(mdctx, bfb, l);
|
||||
n += l;
|
||||
EVP_DigestUpdate(mdctx, bfb, (size_t)l);
|
||||
n += (uint32_t)l;
|
||||
}
|
||||
|
||||
if (!header->sigpos) {
|
||||
/* pad (with 0's) unsigned PE file to 8 byte boundary */
|
||||
int len = 8 - header->fileend % 8;
|
||||
if (len > 0 && len != 8) {
|
||||
memset(bfb, 0, len);
|
||||
EVP_DigestUpdate(mdctx, bfb, len);
|
||||
memset(bfb, 0, (size_t)len);
|
||||
EVP_DigestUpdate(mdctx, bfb, (size_t)len);
|
||||
}
|
||||
}
|
||||
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 += l2;
|
||||
*phlen = obj->value->value.sequence->length - l;
|
||||
*ph = OPENSSL_malloc(*phlen);
|
||||
memcpy(*ph, obj->value->value.sequence->data + l, *phlen);
|
||||
*ph = OPENSSL_malloc((size_t)*phlen);
|
||||
memcpy(*ph, obj->value->value.sequence->data + l, (size_t)*phlen);
|
||||
SpcAttributeTypeAndOptionalValue_free(obj);
|
||||
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));
|
||||
print_hash("Page hash ", "...", ph, (phlen < 32) ? phlen : 32);
|
||||
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);
|
||||
OPENSSL_free(cph);
|
||||
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) {
|
||||
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);
|
||||
}
|
||||
@ -3468,7 +3468,7 @@ static int pe_verify_file(char *indata, FILE_HEADER *header, GLOBAL_OPTIONS *opt
|
||||
|
||||
/* check 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);
|
||||
BIO_free(bio);
|
||||
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);
|
||||
PKCS7_free(sig);
|
||||
} else
|
||||
ret = !BIO_write(outdata, indata + header->sigpos, header->siglen);
|
||||
ret = !BIO_write(outdata, indata + header->sigpos, (int)header->siglen);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@ -3590,24 +3590,24 @@ static void pe_modify_header(char *indata, FILE_HEADER *header, BIO *hash, BIO *
|
||||
int len = 0, i;
|
||||
char *buf = OPENSSL_malloc(SIZE_64K);
|
||||
|
||||
i = header->header_size + 88;
|
||||
i = (int)header->header_size + 88;
|
||||
BIO_write(hash, indata, i);
|
||||
memset(buf, 0, 4);
|
||||
BIO_write(outdata, buf, 4); /* zero out checksum */
|
||||
i += 4;
|
||||
BIO_write(hash, indata + i, 60 + header->pe32plus * 16);
|
||||
i += 60 + header->pe32plus * 16;
|
||||
BIO_write(hash, indata + i, 60 + (int)header->pe32plus * 16);
|
||||
i += 60 + (int)header->pe32plus * 16;
|
||||
memset(buf, 0, 8);
|
||||
BIO_write(outdata, buf, 8); /* zero out sigtable offset + pos */
|
||||
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 */
|
||||
len = 8 - header->fileend % 8;
|
||||
if (len > 0 && len != 8) {
|
||||
memset(buf, 0, len);
|
||||
memset(buf, 0, (size_t)len);
|
||||
BIO_write(hash, buf, len);
|
||||
header->fileend += len;
|
||||
header->fileend += (uint32_t)len;
|
||||
}
|
||||
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");
|
||||
goto err;
|
||||
}
|
||||
bio = BIO_new_mem_buf(indata, offset);
|
||||
bio = BIO_new_mem_buf(indata, (int)offset);
|
||||
memset(mdbuf, 0, EVP_MAX_MD_SIZE);
|
||||
(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;
|
||||
if (want > sizeof bfb)
|
||||
want = sizeof bfb;
|
||||
l = BIO_read(bio, bfb, want);
|
||||
l = BIO_read(bio, bfb, (int)want);
|
||||
if (l <= 0)
|
||||
break;
|
||||
EVP_DigestUpdate(mdctx, bfb, l);
|
||||
coffFiles += l;
|
||||
EVP_DigestUpdate(mdctx, bfb, (size_t)l);
|
||||
coffFiles += (uint32_t)l;
|
||||
}
|
||||
OPENSSL_free(bfb);
|
||||
BIO_free(bio);
|
||||
@ -3836,7 +3836,7 @@ static int cab_verify_pkcs7(SIGNATURE *signature, char *indata, FILE_HEADER *hea
|
||||
if (idc) {
|
||||
if (idc->messageDigest && idc->messageDigest->digest && idc->messageDigest->digestAlgorithm) {
|
||||
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);
|
||||
}
|
||||
@ -3921,7 +3921,7 @@ static int cab_extract_file(char *indata, FILE_HEADER *header, BIO *outdata, int
|
||||
ret = !PEM_write_bio_PKCS7(outdata, sig);
|
||||
PKCS7_free(sig);
|
||||
} else
|
||||
ret = !BIO_write(outdata, indata + header->sigpos, header->siglen);
|
||||
ret = !BIO_write(outdata, indata + header->sigpos, (int)header->siglen);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@ -4023,7 +4023,7 @@ static int cab_remove_file(char *indata, FILE_HEADER *header, uint32_t filesize,
|
||||
nfolders--;
|
||||
}
|
||||
/* 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);
|
||||
|
||||
return 0; /* OK */
|
||||
@ -4033,7 +4033,7 @@ static void cab_modify_header(char *indata, FILE_HEADER *header, BIO *hash, BIO
|
||||
{
|
||||
int i;
|
||||
uint16_t nfolders, flags;
|
||||
const char buf[] = {0x00, 0x00};
|
||||
u_char buf[] = {0x00, 0x00};
|
||||
|
||||
/* u1 signature[4] 4643534D MSCF: 0-3 */
|
||||
BIO_write(hash, indata, 4);
|
||||
@ -4082,7 +4082,7 @@ static void cab_modify_header(char *indata, FILE_HEADER *header, BIO *hash, BIO
|
||||
nfolders--;
|
||||
}
|
||||
/* 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)
|
||||
@ -4149,7 +4149,7 @@ static void cab_add_header(char *indata, FILE_HEADER *header, BIO *hash, BIO *ou
|
||||
nfolders--;
|
||||
}
|
||||
/* 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);
|
||||
}
|
||||
|
||||
@ -4238,7 +4238,7 @@ static int cat_verify_member(CatalogAuthAttr *attribute, char *indata, FILE_HEAD
|
||||
if (idc->messageDigest && idc->messageDigest->digest && idc->messageDigest->digestAlgorithm) {
|
||||
/* get a digest algorithm a message digest of the file from the content */
|
||||
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);
|
||||
}
|
||||
@ -4265,7 +4265,7 @@ static int cat_verify_member(CatalogAuthAttr *attribute, char *indata, FILE_HEAD
|
||||
break;
|
||||
}
|
||||
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));
|
||||
print_hash("Current message digest ", "", mdbuf, 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;
|
||||
|
||||
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);
|
||||
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);
|
||||
if (!si)
|
||||
return 0; /* FAILED */
|
||||
if ((p = OPENSSL_malloc(len)) == NULL)
|
||||
if ((p = OPENSSL_malloc((size_t)len)) == NULL)
|
||||
return 0; /* FAILED */
|
||||
memset(p, 0, len);
|
||||
memset(p, 0, (size_t)len);
|
||||
memcpy(p, prefix, sizeof prefix);
|
||||
memcpy(p + len - sizeof postfix, postfix, sizeof postfix);
|
||||
astr = ASN1_STRING_new();
|
||||
@ -4549,7 +4549,7 @@ static int append_signature(PKCS7 *sig, PKCS7 *cursig, file_type_t type,
|
||||
{
|
||||
u_char *p = NULL;
|
||||
PKCS7 *outsig = NULL;
|
||||
const char buf[] = {
|
||||
u_char buf[] = {
|
||||
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;
|
||||
}
|
||||
/* 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);
|
||||
return 1; /* FAILED */
|
||||
}
|
||||
@ -4585,15 +4585,15 @@ static int append_signature(PKCS7 *sig, PKCS7 *cursig, file_type_t type,
|
||||
BIO_write(outdata, p, *len);
|
||||
/* pad (with 0's) asn1 blob to 8 byte boundary */
|
||||
if (*padlen > 0) {
|
||||
memset(p, 0, *padlen);
|
||||
memset(p, 0, (size_t)*padlen);
|
||||
BIO_write(outdata, p, *padlen);
|
||||
}
|
||||
} else if (type == FILE_TYPE_MSI) {
|
||||
int len_msi = *len;
|
||||
u_char *p_msi = OPENSSL_malloc(len_msi);
|
||||
memcpy(p_msi, p, len_msi);
|
||||
if (!msi_file_write(msiparams->msi, msiparams->dirent, p_msi, len_msi,
|
||||
msiparams->p_msiex, msiparams->len_msiex, outdata)) {
|
||||
u_char *p_msi = OPENSSL_malloc((size_t)len_msi);
|
||||
memcpy(p_msi, p, (size_t)len_msi);
|
||||
if (!msi_file_write(msiparams->msi, msiparams->dirent, p_msi, (uint32_t)len_msi,
|
||||
msiparams->p_msiex, (uint32_t)msiparams->len_msiex, outdata)) {
|
||||
printf("Saving the msi file failed\n");
|
||||
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,
|
||||
int padlen, int len, BIO *outdata)
|
||||
{
|
||||
const char buf[] = {
|
||||
u_char buf[] = {
|
||||
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;
|
||||
}
|
||||
|
||||
static off_t get_file_size(const char *infile)
|
||||
static uint32_t get_file_size(const char *infile)
|
||||
{
|
||||
int ret;
|
||||
#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);
|
||||
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;
|
||||
#ifdef WIN32
|
||||
@ -4860,7 +4860,7 @@ static char *getpassword(const char *prompt)
|
||||
|
||||
tcgetattr(fileno(stdin), &ofl);
|
||||
nfl = ofl;
|
||||
nfl.c_lflag &= ~ECHO;
|
||||
nfl.c_lflag &= ~(unsigned int)ECHO;
|
||||
nfl.c_lflag |= ECHONL;
|
||||
|
||||
if (tcsetattr(fileno(stdin), TCSANOW, &nfl) != 0) {
|
||||
@ -4915,7 +4915,7 @@ static int read_password(GLOBAL_OPTIONS *options)
|
||||
if (passfd < 0) {
|
||||
return 0; /* FAILED */
|
||||
}
|
||||
passlen = read(passfd, passbuf, sizeof passbuf - 1);
|
||||
passlen = (int)read(passfd, passbuf, sizeof passbuf - 1);
|
||||
close(passfd);
|
||||
#endif /* WIN32 */
|
||||
if (passlen <= 0) {
|
||||
@ -4930,7 +4930,7 @@ static int read_password(GLOBAL_OPTIONS *options)
|
||||
} else {
|
||||
options->pass = OPENSSL_strdup(passbuf);
|
||||
}
|
||||
memset(passbuf, 0, sizeof(passbuf));
|
||||
memset(passbuf, 0, sizeof passbuf);
|
||||
#ifdef PROVIDE_ASKPASS
|
||||
} else if (options->askpass) {
|
||||
options->pass = getpassword("Password: ");
|
||||
@ -5364,7 +5364,7 @@ static PKCS7 *get_sigfile(char *sigfile, file_type_t type)
|
||||
return NULL; /* FAILED */
|
||||
}
|
||||
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);
|
||||
BIO_free_all(sigbio);
|
||||
} else {
|
||||
@ -5479,7 +5479,7 @@ static PKCS7 *msi_presign_file(file_type_t type, cmd_type_t cmd, FILE_HEADER *he
|
||||
return NULL; /* FAILED */
|
||||
}
|
||||
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);
|
||||
OPENSSL_free(data);
|
||||
if (!*cursig) {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user