/* * Copyright (C) 2013-2019 Cisco Systems, Inc. and/or its affiliates. All rights reserved. * Copyright (C) 2011-2013 Sourcefire, Inc. * * Authors: aCaB * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, * MA 02110-1301, USA. */ #if HAVE_CONFIG_H #include "clamav-config.h" #endif #include #include "clamav.h" #include "asn1.h" #include "bignum.h" #include "matcher-hash.h" /* --------------------------------------------------------------------------- OIDS */ #define OID_1_3_14_3_2_26 "\x2b\x0e\x03\x02\x1a" #define OID_sha1 OID_1_3_14_3_2_26 #define OID_1_3_14_3_2_29 "\x2b\x0e\x03\x02\x1d" #define OID_sha1WithRSA OID_1_3_14_3_2_29 #define OID_1_2_840_113549_1_1_1 "\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01" #define OID_rsaEncryption OID_1_2_840_113549_1_1_1 #define OID_1_2_840_113549_1_1_2 "\x2a\x86\x48\x86\xf7\x0d\x01\x01\x02" #define OID_md2WithRSAEncryption OID_1_2_840_113549_1_1_2 #define OID_1_2_840_113549_1_1_4 "\x2a\x86\x48\x86\xf7\x0d\x01\x01\x04" #define OID_md5WithRSAEncryption OID_1_2_840_113549_1_1_4 #define OID_1_2_840_113549_1_1_5 "\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05" #define OID_sha1WithRSAEncryption OID_1_2_840_113549_1_1_5 #define OID_1_2_840_113549_1_1_11 "\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0b" #define OID_sha256WithRSAEncryption OID_1_2_840_113549_1_1_11 #define OID_1_2_840_113549_1_1_12 "\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0c" #define OID_sha384WithRSAEncryption OID_1_2_840_113549_1_1_12 #define OID_1_2_840_113549_1_1_13 "\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0d" #define OID_sha512WithRSAEncryption OID_1_2_840_113549_1_1_13 #define OID_1_2_840_113549_1_7_1 "\x2a\x86\x48\x86\xf7\x0d\x01\x07\x01" #define OID_pkcs7_data OID_1_2_840_113549_1_7_1 #define OID_1_2_840_113549_1_7_2 "\x2a\x86\x48\x86\xf7\x0d\x01\x07\x02" #define OID_signedData OID_1_2_840_113549_1_7_2 #define OID_1_2_840_113549_1_9_3 "\x2a\x86\x48\x86\xf7\x0d\x01\x09\x03" #define OID_contentType OID_1_2_840_113549_1_9_3 #define OID_1_2_840_113549_1_9_4 "\x2a\x86\x48\x86\xf7\x0d\x01\x09\x04" #define OID_messageDigest OID_1_2_840_113549_1_9_4 #define OID_1_2_840_113549_1_9_5 "\x2a\x86\x48\x86\xf7\x0d\x01\x09\x05" #define OID_signingTime OID_1_2_840_113549_1_9_5 #define OID_1_2_840_113549_2_5 "\x2a\x86\x48\x86\xf7\x0d\x02\x05" #define OID_md5 OID_1_2_840_113549_2_5 #define OID_1_2_840_113549_1_9_6 "\x2a\x86\x48\x86\xf7\x0d\x01\x09\x06" #define OID_countersignature OID_1_2_840_113549_1_9_6 #define OID_1_2_840_113549_1_9_16_1_4 "\x2a\x86\x48\x86\xf7\x0d\x01\x09\x10\x01\x04" #define OID_timestampToken OID_1_2_840_113549_1_9_16_1_4 #define OID_1_3_6_1_4_1_311_2_1_4 "\x2b\x06\x01\x04\x01\x82\x37\x02\x01\x04" #define OID_SPC_INDIRECT_DATA_OBJID OID_1_3_6_1_4_1_311_2_1_4 #define OID_1_3_6_1_4_1_311_2_1_15 "\x2b\x06\x01\x04\x01\x82\x37\x02\x01\x0f" #define OID_SPC_PE_IMAGE_DATA_OBJID OID_1_3_6_1_4_1_311_2_1_15 #define OID_1_3_6_1_4_1_311_2_1_25 "\x2b\x06\x01\x04\x01\x82\x37\x02\x01\x19" #define OID_SPC_CAB_DATA_OBJID OID_1_3_6_1_4_1_311_2_1_25 #define OID_1_3_6_1_4_1_311_2_4_1 "\x2b\x06\x01\x04\x01\x82\x37\x02\x04\x01" #define OID_nestedSignatures OID_1_3_6_1_4_1_311_2_4_1 #define OID_1_3_6_1_4_1_311_10_1 "\x2b\x06\x01\x04\x01\x82\x37\x0a\x01" #define OID_szOID_CTL OID_1_3_6_1_4_1_311_10_1 #define OID_1_3_6_1_4_1_311_12_1_1 "\x2b\x06\x01\x04\x01\x82\x37\x0c\x01\x01" #define OID_szOID_CATALOG_LIST OID_1_3_6_1_4_1_311_12_1_1 #define OID_1_3_6_1_4_1_311_12_1_2 "\x2b\x06\x01\x04\x01\x82\x37\x0c\x01\x02" #define OID_szOID_CATALOG_LIST_MEMBER OID_1_3_6_1_4_1_311_12_1_2 #define OID_2_16_840_1_101_3_4_2_1 "\x60\x86\x48\x01\x65\x03\x04\x02\x01" #define OID_sha256 OID_2_16_840_1_101_3_4_2_1 #define OID_2_16_840_1_101_3_4_2_2 "\x60\x86\x48\x01\x65\x03\x04\x02\x02" #define OID_sha384 OID_2_16_840_1_101_3_4_2_2 #define OID_2_16_840_1_101_3_4_2_3 "\x60\x86\x48\x01\x65\x03\x04\x02\x03" #define OID_sha512 OID_2_16_840_1_101_3_4_2_3 /* --------------------------------------------------------------------------- OIDS */ #define lenof(x) (sizeof((x))-1) #define ASN1_TYPE_BOOLEAN 0x01 #define ASN1_TYPE_INTEGER 0x02 #define ASN1_TYPE_BIT_STRING 0x03 #define ASN1_TYPE_OCTET_STRING 0x04 #define ASN1_TYPE_NULL 0x05 #define ASN1_TYPE_OBJECT_ID 0x06 #define ASN1_TYPE_SEQUENCE 0x30 #define ASN1_TYPE_SET 0x31 #define MAX_HASH_SIZE SHA512_HASH_SIZE struct cli_asn1 { uint8_t type; unsigned int size; const void *content; const void *next; }; static int map_raw(fmap_t *map, const void *data, unsigned int len, uint8_t raw[CRT_RAWMAXLEN]) { unsigned int elen = MIN(len, CRT_RAWMAXLEN-1); if(!fmap_need_ptr_once(map, data, elen)) { cli_dbgmsg("map_raw: failed to read map data\n"); return 1; } memset(raw, 0, CRT_RAWMAXLEN); raw[0] = (uint8_t)elen; memcpy(&raw[1], data, elen); return 0; } static int map_sha512(fmap_t *map, const void *data, unsigned int len, uint8_t sha512[SHA512_HASH_SIZE]) { if(!fmap_need_ptr_once(map, data, len)) { cli_dbgmsg("map_sha512: failed to read hash data\n"); return 1; } return (cl_sha512(data, len, sha512, NULL) == NULL); } static int map_sha384(fmap_t *map, const void *data, unsigned int len, uint8_t sha384[SHA384_HASH_SIZE]) { if(!fmap_need_ptr_once(map, data, len)) { cli_dbgmsg("map_sha384: failed to read hash data\n"); return 1; } return (cl_sha384(data, len, sha384, NULL) == NULL); } static int map_sha256(fmap_t *map, const void *data, unsigned int len, uint8_t sha256[SHA256_HASH_SIZE]) { if(!fmap_need_ptr_once(map, data, len)) { cli_dbgmsg("map_sha256: failed to read hash data\n"); return 1; } return (cl_sha256(data, len, sha256, NULL) == NULL); } static int map_sha1(fmap_t *map, const void *data, unsigned int len, uint8_t sha1[SHA1_HASH_SIZE]) { if(!fmap_need_ptr_once(map, data, len)) { cli_dbgmsg("map_sha1: failed to read hash data\n"); return 1; } return (cl_sha1(data, len, sha1, NULL) == NULL); } static int map_md5(fmap_t *map, const void *data, unsigned int len, uint8_t *md5) { if(!fmap_need_ptr_once(map, data, len)) { cli_dbgmsg("map_md5: failed to read hash data\n"); return 1; } return (cl_hash_data("md5", data, len, md5, NULL) == NULL); } static int map_hash(fmap_t *map, const void *data, unsigned int len, uint8_t *out_hash, cli_crt_hashtype hashtype) { if(hashtype == CLI_SHA1RSA) { if(map_sha1(map, data, len, out_hash)) { return 1; } } else if(hashtype == CLI_MD5RSA) { if(map_md5(map, data, len, out_hash)) { return 1; } } else if(hashtype == CLI_SHA256RSA) { if(map_sha256(map, data, len, out_hash)) { return 1; } } else if(hashtype == CLI_SHA384RSA) { if(map_sha384(map, data, len, out_hash)) { return 1; } } else if(hashtype == CLI_SHA512RSA) { if(map_sha512(map, data, len, out_hash)) { return 1; } } else { cli_dbgmsg("asn1_map_hash: unsupported hashtype\n"); return 1; } return 0; } static void * get_hash_ctx(cli_crt_hashtype hashtype) { void *ctx = NULL; if(hashtype == CLI_SHA1RSA) { ctx = cl_hash_init("sha1"); } else if (hashtype == CLI_MD5RSA) { ctx = cl_hash_init("md5"); } else if (hashtype == CLI_SHA256RSA) { ctx = cl_hash_init("sha256"); } else if (hashtype == CLI_SHA384RSA) { ctx = cl_hash_init("sha384"); } else if (hashtype == CLI_SHA512RSA) { ctx = cl_hash_init("sha512"); } else { cli_dbgmsg("asn1_get_hash_ctx: unsupported hashtype\n"); } return ctx; } static int asn1_get_obj(fmap_t *map, const void *asn1data, unsigned int *asn1len, struct cli_asn1 *obj) { unsigned int asn1_sz = *asn1len; unsigned int readbytes = MIN(6, asn1_sz), i; const uint8_t *data; if(asn1_sz < 2) { cli_dbgmsg("asn1_get_obj: insufficient data length\n"); return 1; } data = fmap_need_ptr_once(map, asn1data, readbytes); if(!data) { cli_dbgmsg("asn1_get_obj: obj out of file\n"); return 1; } obj->type = data[0]; i = data[1]; data+=2; if(i & 0x80) { if(i == 0x80) { /* Not allowed in DER */ cli_dbgmsg("asn1_get_obj: unsupported indefinite length object\n"); return 1; } i &= ~0x80; if(i > readbytes - 2) { cli_dbgmsg("asn1_get_obj: len octets overflow (or just too many)\n"); return 1; } obj->size = 0; while(i--) { obj->size <<= 8; obj->size |= *data; data ++; } } else obj->size = i; asn1_sz -= data - (uint8_t *)asn1data; if(obj->size > asn1_sz) { cli_dbgmsg("asn1_get_obj: content overflow\n"); return 1; } obj->content = data; if(obj->size == asn1_sz) obj->next = NULL; else obj->next = data + obj->size; *asn1len = asn1_sz - obj->size; return 0; } static int asn1_expect_objtype(fmap_t *map, const void *asn1data, unsigned int *asn1len, struct cli_asn1 *obj, uint8_t type) { int ret = asn1_get_obj(map, asn1data, asn1len, obj); if(ret) return ret; if(obj->type != type) { cli_dbgmsg("asn1_expect_objtype: expected type %02x, got %02x\n", type, obj->type); return 1; } return 0; } static int asn1_expect_obj(fmap_t *map, const void **asn1data, unsigned int *asn1len, uint8_t type, unsigned int size, const void *content) { struct cli_asn1 obj; int ret = asn1_expect_objtype(map, *asn1data, asn1len, &obj, type); if(ret) return ret; if(obj.size != size) { cli_dbgmsg("asn1_expect_obj: expected size %u, got %u\n", size, obj.size); return 1; } if(size) { if(!fmap_need_ptr_once(map, obj.content, size)) { cli_dbgmsg("asn1_expect_obj: failed to read content\n"); return 1; } if(memcmp(obj.content, content, size)) { cli_dbgmsg("asn1_expect_obj: content mismatch\n"); return 1; } } *asn1data = obj.next; return 0; } static int asn1_expect_algo(fmap_t *map, const void **asn1data, unsigned int *asn1len, unsigned int algo_size, const void *algo) { struct cli_asn1 obj; unsigned int avail; int ret; if((ret = asn1_expect_objtype(map, *asn1data, asn1len, &obj, ASN1_TYPE_SEQUENCE))) /* SEQUENCE */ return ret; avail = obj.size; *asn1data = obj.next; if((ret = asn1_expect_obj(map, &obj.content, &avail, ASN1_TYPE_OBJECT_ID, algo_size, algo))) /* ALGO */ return ret; // The specification says that the NULL is a required parameter for this // data type, but in practice it doesn't always exist in the ASN1. If // there is something after the ALGO OID, assume it's the NULL if(avail && (ret = asn1_expect_obj(map, &obj.content, &avail, ASN1_TYPE_NULL, 0, NULL))) { /* NULL */ cli_dbgmsg("asn1_expect_algo: expected NULL after AlgorithmIdentifier OID\n"); return ret; } if(avail) { cli_dbgmsg("asn1_expect_algo: extra data found in SEQUENCE\n"); return 1; } return 0; } static int asn1_expect_hash_algo(fmap_t *map, const void **asn1data, unsigned int *asn1len, cli_crt_hashtype *hashtype, unsigned int *hashsize) { struct cli_asn1 obj; unsigned int avail; int ret; if(ret = asn1_expect_objtype(map, *asn1data, asn1len, &obj, ASN1_TYPE_SEQUENCE)) { cli_dbgmsg("asn1_expect_hash_algo: expected SEQUENCE to start AlgorithmIdentifier\n"); return ret; } avail = obj.size; *asn1data = obj.next; if(ret = asn1_expect_objtype(map, obj.content, &avail, &obj, ASN1_TYPE_OBJECT_ID)) { cli_dbgmsg("asn1_expect_hash_algo: unexpected object type inside AlgorithmIdentifier SET\n"); return ret; } /* Cases to consider for the length check: * - obj.size == 5: * - OID_sha1 * - obj.size == 8: * - OID_md5 * - obj.size == 9: * - OID_sha256 * - OID_sha1WithRSAEncryption * - OID_md5WithRSAEncryption * - OID_sha256WithRSAEncryption * - OID_sha384 * - OID_sha384WithRSAEncryption * - OID_sha512 * - OID_sha512WithRSAEncryption */ if(obj.size != lenof(OID_sha1) && obj.size != lenof(OID_md5) && obj.size != lenof(OID_sha256)) { cli_dbgmsg("asn1_expect_hash_algo: unsupported algorithm OID size for AlgorithmIdentifier\n"); return 1; } if(!fmap_need_ptr_once(map, obj.content, obj.size)) { cli_dbgmsg("asn1_expect_hash_algo: failed to get AlgorithmIdentifier OID\n"); return 1; } if((obj.size == lenof(OID_sha1) && !memcmp(obj.content, OID_sha1, lenof(OID_sha1))) || (obj.size == lenof(OID_sha1WithRSAEncryption) && !memcmp(obj.content, OID_sha1WithRSAEncryption, lenof(OID_sha1WithRSAEncryption)))) { *hashtype = CLI_SHA1RSA; *hashsize = SHA1_HASH_SIZE; } else if((obj.size == lenof(OID_md5) && !memcmp(obj.content, OID_md5, lenof(OID_md5))) || (obj.size == lenof(OID_md5WithRSAEncryption) && !memcmp(obj.content, OID_md5WithRSAEncryption, lenof(OID_md5WithRSAEncryption)))) { *hashtype = CLI_MD5RSA; *hashsize = MD5_HASH_SIZE; } else if((obj.size == lenof(OID_sha256) && !memcmp(obj.content, OID_sha256, lenof(OID_sha256))) || (obj.size == lenof(OID_sha256WithRSAEncryption) && !memcmp(obj.content, OID_sha256WithRSAEncryption, lenof(OID_sha256WithRSAEncryption)))) { *hashtype = CLI_SHA256RSA; *hashsize = SHA256_HASH_SIZE; } else if((obj.size == lenof(OID_sha384) && !memcmp(obj.content, OID_sha384, lenof(OID_sha384))) || (obj.size == lenof(OID_sha384WithRSAEncryption) && !memcmp(obj.content, OID_sha384WithRSAEncryption, lenof(OID_sha384WithRSAEncryption)))) { *hashtype = CLI_SHA384RSA; *hashsize = SHA384_HASH_SIZE; } else if((obj.size == lenof(OID_sha512) && !memcmp(obj.content, OID_sha512, lenof(OID_sha512))) || (obj.size == lenof(OID_sha512WithRSAEncryption) && !memcmp(obj.content, OID_sha512WithRSAEncryption, lenof(OID_sha512WithRSAEncryption)))) { *hashtype = CLI_SHA512RSA; *hashsize = SHA512_HASH_SIZE; } else { cli_dbgmsg("asn1_expect_hash_algo: unknown digest OID in AlgorithmIdentifier\n"); return 1; } // The specification says that the NULL is a required parameter for this // data type, but in practice it doesn't always exist in the ASN1. If // there is something after the ALGO OID, assume it's the NULL if(avail && (ret = asn1_expect_obj(map, &obj.next, &avail, ASN1_TYPE_NULL, 0, NULL))) { cli_dbgmsg("asn1_expect_hash_algo: expected NULL after AlgorithmIdentifier OID\n"); return ret; } if(avail) { cli_dbgmsg("asn1_expect_hash_algo: extra data in AlgorithmIdentifier\n"); return 1; } return 0; } static int asn1_expect_rsa(fmap_t *map, const void **asn1data, unsigned int *asn1len, cli_crt_hashtype *hashtype) { struct cli_asn1 obj; unsigned int avail; int ret; if((ret = asn1_expect_objtype(map, *asn1data, asn1len, &obj, ASN1_TYPE_SEQUENCE))) { /* SEQUENCE */ cli_dbgmsg("asn1_expect_rsa: expecting SEQUENCE at the start of the RSA algo\n"); return ret; } avail = obj.size; *asn1data = obj.next; if(asn1_expect_objtype(map, obj.content, &avail, &obj, ASN1_TYPE_OBJECT_ID)) { cli_dbgmsg("asn1_expect_rsa: expected OID in RSA algo\n"); return 1; } // Two cases to check for: // obj.size == 5: // - OID_sha1WithRSA // // obj.size == 9: // - OID_rsaEncryption // - OID_md2WithRSAEncryption // - OID_md5WithRSAEncryption // - OID_sha1WithRSAEncryption // - OID_sha256WithRSAEncryption // - OID_sha384WithRSAEncryption // - OID_sha512WithRSAEncryption if(obj.size != lenof(OID_sha1WithRSA) && obj.size != lenof(OID_sha1WithRSAEncryption)) { cli_dbgmsg("asn1_expect_rsa: expecting OID with size 5 or 9, got %02x with size %u\n", obj.type, obj.size); return 1; } if(!fmap_need_ptr_once(map, obj.content, obj.size)) { cli_dbgmsg("asn1_expect_rsa: failed to read OID\n"); return 1; } if(obj.size == lenof(OID_sha1WithRSA)) { if(!memcmp(obj.content, OID_sha1WithRSA, lenof(OID_sha1WithRSA))) { *hashtype = CLI_SHA1RSA; /* Obsolete sha1rsa 1.3.14.3.2.29 */ } else { cli_dbgmsg("asn1_expect_rsa: unknown OID (length 5)\n"); return 1; } } else if (obj.size == lenof(OID_sha1WithRSAEncryption)) { if(!memcmp(obj.content, OID_sha1WithRSAEncryption, lenof(OID_sha1WithRSAEncryption))) *hashtype = CLI_SHA1RSA; /* sha1withRSAEncryption 1.2.840.113549.1.1.5 */ else if(!memcmp(obj.content, OID_md5WithRSAEncryption, lenof(OID_md5WithRSAEncryption))) *hashtype = CLI_MD5RSA; /* md5withRSAEncryption 1.2.840.113549.1.1.4 */ else if(!memcmp(obj.content, OID_rsaEncryption, lenof(OID_rsaEncryption))) *hashtype = CLI_RSA; /* rsaEncryption 1.2.840.113549.1.1.1 */ else if(!memcmp(obj.content, OID_md2WithRSAEncryption, lenof(OID_md2WithRSAEncryption))) { *hashtype = CLI_MD2RSA; /* md2withRSAEncryption 1.2.840.113549.1.1.2 */ } else if(!memcmp(obj.content, OID_sha256WithRSAEncryption, lenof(OID_sha256WithRSAEncryption))) { *hashtype = CLI_SHA256RSA; /* sha256WithRSAEncryption 1.2.840.113549.1.1.11 */ } else if(!memcmp(obj.content, OID_sha384WithRSAEncryption, lenof(OID_sha384WithRSAEncryption))) { *hashtype = CLI_SHA384RSA; /* sha384WithRSAEncryption 1.2.840.113549.1.1.12 */ } else if(!memcmp(obj.content, OID_sha512WithRSAEncryption, lenof(OID_sha512WithRSAEncryption))) { *hashtype = CLI_SHA512RSA; /* sha512WithRSAEncryption 1.2.840.113549.1.1.13 */ } else { cli_dbgmsg("asn1_expect_rsa: unknown OID (length 9)\n"); return 1; } } else { cli_dbgmsg("asn1_expect_rsa: OID mismatch (size %u)\n", obj.size); return 1; } // The specification says that the NULL is a required parameter for this // data type, but in practice it doesn't always exist in the ASN1. If // there is something after the ALGO OID, assume it's the NULL if(avail && (ret = asn1_expect_obj(map, &obj.next, &avail, ASN1_TYPE_NULL, 0, NULL))) { /* NULL */ cli_dbgmsg("asn1_expect_rsa: expected NULL following RSA OID\n"); return ret; } if(avail) { cli_dbgmsg("asn1_expect_rsa: extra data found in SEQUENCE\n"); return 1; } return 0; } static int asn1_getnum(const char *s) { if(s[0] < '0' || s[0] >'9' || s[1] < '0' || s[1] > '9') { cli_dbgmsg("asn1_getnum: expecting digits, found '%c%c'\n", s[0], s[1]); return -1; } return (s[0] - '0')*10 + (s[1] - '0'); } static int asn1_get_time(fmap_t *map, const void **asn1data, unsigned int *size, time_t *tm) { struct cli_asn1 obj; int ret = asn1_get_obj(map, *asn1data, size, &obj); unsigned int len; char *ptr; struct tm t; int n; if(ret) return ret; if(obj.type == 0x17) /* UTCTime - YYMMDDHHMMSSZ */ len = 13; else if(obj.type == 0x18) /* GeneralizedTime - YYYYMMDDHHMMSSZ */ len = 15; else { cli_dbgmsg("asn1_get_time: expected UTCTime or GeneralizedTime, got %02x\n", obj.type); return 1; } if(!fmap_need_ptr_once(map, obj.content, len)) { cli_dbgmsg("asn1_get_time: failed to read content\n"); return 1; } memset(&t, 0, sizeof(t)); ptr = (char *)obj.content; if(obj.type == 0x18) { t.tm_year = asn1_getnum(ptr) * 100; if(t.tm_year < 0) return 1; n = asn1_getnum(ptr); if(n<0) return 1; t.tm_year += n; ptr+=4; } else { n = asn1_getnum(ptr); if(n<0) return 1; if(n>=50) t.tm_year = 1900 + n; else t.tm_year = 2000 + n; ptr += 2; } t.tm_year -= 1900; n = asn1_getnum(ptr); if(n<1 || n>12) { cli_dbgmsg("asn1_get_time: invalid month %u\n", n); return 1; } t.tm_mon = n - 1; ptr+=2; n = asn1_getnum(ptr); if(n<1 || n>31) { cli_dbgmsg("asn1_get_time: invalid day %u\n", n); return 1; } t.tm_mday = n; ptr+=2; n = asn1_getnum(ptr); if(n<0 || n>23) { cli_dbgmsg("asn1_get_time: invalid hour %u\n", n); return 1; } t.tm_hour = n; ptr+=2; n = asn1_getnum(ptr); if(n<0 || n>59) { cli_dbgmsg("asn1_get_time: invalid minute %u\n", n); return 1; } t.tm_min = n; ptr+=2; n = asn1_getnum(ptr); if(n<0 || n>59) { cli_dbgmsg("asn1_get_time: invalid second %u\n", n); return 1; } t.tm_sec = n; ptr+=2; if(*ptr != 'Z') { cli_dbgmsg("asn1_get_time: expected UTC time 'Z', got '%c'\n", *ptr); return 1; } *tm = mktime(&t); *asn1data = obj.next; return 0; } static int asn1_get_rsa_pubkey(fmap_t *map, const void **asn1data, unsigned int *size, cli_crt *x509) { struct cli_asn1 obj; unsigned int avail, avail2; if(asn1_expect_objtype(map, *asn1data, size, &obj, ASN1_TYPE_SEQUENCE)) /* subjectPublicKeyInfo */ return 1; *asn1data = obj.next; avail = obj.size; if(asn1_expect_algo(map, &obj.content, &avail, lenof(OID_rsaEncryption), OID_rsaEncryption)) { /* rsaEncryption */ cli_dbgmsg("asn1_get_rsa_pubkey: AlgorithmIdentifier other than RSA not yet supported\n"); return 1; } if(asn1_expect_objtype(map, obj.content, &avail, &obj, ASN1_TYPE_BIT_STRING)) /* BIT STRING - subjectPublicKey */ return 1; if(avail) { cli_dbgmsg("asn1_get_rsa_pubkey: found unexpected extra data in subjectPublicKeyInfo\n"); return 1; } /* if(obj.size != 141 && obj.size != 271) /\* encoded len of 1024 and 2048 bit public keys *\/ */ /* return 1; */ if(!fmap_need_ptr_once(map, obj.content, 1)) { cli_dbgmsg("asn1_get_rsa_pubkey: cannot read public key content\n"); return 1; } if(((uint8_t *)obj.content)[0] != 0) { /* no byte fragments */ cli_dbgmsg("asn1_get_rsa_pubkey: unexpected byte frags in public key\n"); return 1; } avail = obj.size - 1; obj.content = ((uint8_t *)obj.content) + 1; if(asn1_expect_objtype(map, obj.content, &avail, &obj, ASN1_TYPE_SEQUENCE)) /* SEQUENCE */ return 1; if(avail) { cli_dbgmsg("asn1_get_rsa_pubkey: found unexpected extra data in public key content\n"); return 1; } avail = obj.size; if(asn1_expect_objtype(map, obj.content, &avail, &obj, ASN1_TYPE_INTEGER)) /* INTEGER - mod */ return 1; if(obj.size < 1024/8 || obj.size > 4096/8+1) { cli_dbgmsg("asn1_get_rsa_pubkey: modulus has got an unsupported length (%u)\n", obj.size * 8); return 1; } avail2 = obj.size; if(!fmap_need_ptr_once(map, obj.content, avail2)) { cli_dbgmsg("asn1_get_rsa_pubkey: cannot read n\n"); return 1; } if(mp_read_unsigned_bin(&x509->n, obj.content, avail2)) { cli_dbgmsg("asn1_get_rsa_pubkey: cannot convert n to big number\n"); return 1; } if(asn1_expect_objtype(map, obj.next, &avail, &obj, ASN1_TYPE_INTEGER)) /* INTEGER - exp */ return 1; if(avail) { cli_dbgmsg("asn1_get_rsa_pubkey: found unexpected extra data after exp\n"); return 1; } if(obj.size < 1 || obj.size > avail2) { cli_dbgmsg("asn1_get_rsa_pubkey: exponent has got an unsupported length (%u)\n", obj.size * 8); return 1; } if(!fmap_need_ptr_once(map, obj.content, obj.size)) { cli_dbgmsg("asn1_get_rsa_pubkey: cannot read e\n"); return 1; } if(mp_read_unsigned_bin(&x509->e, obj.content, obj.size)) { cli_dbgmsg("asn1_get_rsa_pubkey: cannot convert e to big number\n"); return 1; } return 0; } #define ASN1_GET_X509_SUCCESS 0 #define ASN1_GET_X509_CERT_ERROR 1 #define ASN1_GET_X509_UNRECOVERABLE_ERROR 2 /* Parse the asn1data associated with an x509 certificate and add the cert * to the crtmgr certs if it doesn't already exist there. * ASN1_GET_X509_CERT_ERROR will be returned in the case that an invalid x509 * certificate is encountered but asn1data and size are suitable for continued * signature parsing. ASN1_GET_X509_UNRECOVERABLE_ERROR will be returned in * the case where asn1data and size are not suitable for continued use. */ static int asn1_get_x509(fmap_t *map, const void **asn1data, unsigned int *size, crtmgr *crts) { struct cli_asn1 crt, tbs, obj; unsigned int avail, tbssize, issuersize; cli_crt_hashtype hashtype1, hashtype2; cli_crt x509; const uint8_t *tbsdata; const void *next, *issuer; int ret = ASN1_GET_X509_UNRECOVERABLE_ERROR; unsigned int version; if(cli_crt_init(&x509)) return ret; do { if(asn1_expect_objtype(map, *asn1data, size, &crt, ASN1_TYPE_SEQUENCE)) { /* SEQUENCE */ cli_dbgmsg("asn1_get_x509: expected SEQUENCE at the x509 start\n"); break; } *asn1data = crt.next; /* After this point, an error is recoverable because asn1data and size * will be suitable for continued use by the caller, so change ret */ ret = ASN1_GET_X509_CERT_ERROR; tbsdata = crt.content; if(asn1_expect_objtype(map, crt.content, &crt.size, &tbs, ASN1_TYPE_SEQUENCE)) { /* SEQUENCE - TBSCertificate */ cli_dbgmsg("asn1_get_x509: expected SEQUENCE at the TBSCertificate start\n"); break; } tbssize = (uint8_t *)tbs.next - tbsdata; /* The version field of the x509 certificate is optional, defaulting * to 1 if the field is not present. Version 3 is backward compatible, * adding the optional issuerUniqueID, sujectUniqueID, and extensions * fields. We'll try to handle both cases, since the Windows API * appears to allow for both (despite the fact that the 2008 spec doc * says that v3 certificates are used for everything) */ if (asn1_get_obj(map, tbs.content, &tbs.size, &obj)) { cli_dbgmsg("asn1_get_x509: failed to get first item in the TBSCertificate\n"); break; } if(0xa0 == obj.type) { /* [0] */ avail = obj.size; next = obj.next; // TODO Should we support v2 certs? Supposedly they are not widely used... if(asn1_expect_obj(map, &obj.content, &avail, ASN1_TYPE_INTEGER, 1, "\x02")) { /* version 3 only (indicated by '\x02')*/ cli_dbgmsg("asn1_get_x509: unexpected type or value for TBSCertificate version\n"); break; } if(avail) { cli_dbgmsg("asn1_get_x509: found unexpected extra data in version\n"); break; } version = 3; if(asn1_expect_objtype(map, next, &tbs.size, &obj, ASN1_TYPE_INTEGER)) { /* serialNumber */ cli_dbgmsg("asn1_get_x509: expected x509 serial INTEGER\n"); break; } } else if (ASN1_TYPE_INTEGER == obj.type) { /* The version field is missing, so we'll assume that this is a * version 1 certificate. obj points to the serialNumber * INTEGER, then, so just continue on to map it. */ version = 1; /* v1 certificates don't have enough information to convey the * purpose of the certificate. I've only ever seen these used * in the timestamp signing chain, so set the flags to indicate * that. */ x509.certSign = 1; x509.codeSign = 0; x509.timeSign = 1; } else { cli_dbgmsg("asn1_get_x509: expected version or serialNumber as the first item in TBSCertificate\n"); break; } if(map_raw(map, obj.content, obj.size, x509.raw_serial)) break; if(map_sha1(map, obj.content, obj.size, x509.serial)) break; if(asn1_expect_rsa(map, &obj.next, &tbs.size, &hashtype1)) { /* algo - Ex: sha1WithRSAEncryption */ cli_dbgmsg("asn1_get_x509: unable to parse AlgorithmIdentifier\n"); break; } if(asn1_expect_objtype(map, obj.next, &tbs.size, &obj, ASN1_TYPE_SEQUENCE)) { /* issuer */ cli_dbgmsg("asn1_get_x509: expected SEQUENCE when parsing cert issuer\n"); break; } issuer = obj.content; issuersize = obj.size; if(asn1_expect_objtype(map, obj.next, &tbs.size, &obj, ASN1_TYPE_SEQUENCE)) { /* validity */ cli_dbgmsg("asn1_get_x509: expected SEQUENCE when parsing cert validity\n"); break; } avail = obj.size; next = obj.content; if(asn1_get_time(map, &next, &avail, &x509.not_before)) { /* notBefore */ cli_dbgmsg("asn1_get_x509: unable to extract the notBefore time\n"); break; } if(asn1_get_time(map, &next, &avail, &x509.not_after)) { /* notAfter */ cli_dbgmsg("asn1_get_x509: unable to extract the notAfter time\n"); break; } if(x509.not_before >= x509.not_after) { cli_dbgmsg("asn1_get_x509: bad validity\n"); break; } if(avail) { cli_dbgmsg("asn1_get_x509: found unexpected extra data in validity\n"); break; } if(asn1_expect_objtype(map, obj.next, &tbs.size, &obj, ASN1_TYPE_SEQUENCE)) { /* subject */ cli_dbgmsg("asn1_get_x509: expected SEQUENCE when parsing cert subject\n"); break; } if(map_raw(map, obj.content, obj.size, x509.raw_subject)) break; if(map_sha1(map, obj.content, obj.size, x509.subject)) break; if(asn1_get_rsa_pubkey(map, &obj.next, &tbs.size, &x509)) { /* subjectPublicKeyInfo */ cli_dbgmsg("asn1_get_x509: failed to get RSA public key\n"); break; } if (1 == version && tbs.size) { cli_dbgmsg("asn1_get_x509: TBSCertificate should not contain fields beyond subjectPublicKeyInfo if version == 1\n"); break; } avail = 0; while(tbs.size) { if(asn1_get_obj(map, obj.next, &tbs.size, &obj)) { tbs.size = 1; break; } if(obj.type <= 0xa0 + avail || obj.type > 0xa3) { cli_dbgmsg("asn1_get_x509: found type %02x in extensions, expecting a1, a2 or a3\n", obj.type); tbs.size = 1; break; } avail = obj.type - 0xa0; if(obj.type == 0xa3) { struct cli_asn1 exts; int have_key_usage = 0; int have_ext_key = 0; if(asn1_expect_objtype(map, obj.content, &obj.size, &exts, ASN1_TYPE_SEQUENCE)) { tbs.size = 1; break; } if(obj.size) { cli_dbgmsg("asn1_get_x509: found unexpected extra data in extensions\n"); break; } while(exts.size) { struct cli_asn1 ext, id, value; if(asn1_expect_objtype(map, exts.content, &exts.size, &ext, ASN1_TYPE_SEQUENCE)) { exts.size = 1; break; } exts.content = ext.next; if(asn1_expect_objtype(map, ext.content, &ext.size, &id, ASN1_TYPE_OBJECT_ID)) { exts.size = 1; break; } if(asn1_get_obj(map, id.next, &ext.size, &value)) { exts.size = 1; break; } if(value.type == ASN1_TYPE_BOOLEAN) { /* critical flag */ if(value.size != 1) { cli_dbgmsg("asn1_get_x509: found boolean with wrong length\n"); exts.size = 1; break; } if(asn1_get_obj(map, value.next, &ext.size, &value)) { exts.size = 1; break; } } if(value.type != ASN1_TYPE_OCTET_STRING) { cli_dbgmsg("asn1_get_x509: bad extension value type %u\n", value.type); exts.size = 1; break; } if(ext.size) { cli_dbgmsg("asn1_get_x509: extra data in extension\n"); exts.size = 1; break; } if(id.size != 3) continue; if(!fmap_need_ptr_once(map, id.content, 3)) { exts.size = 1; break; } if(!memcmp("\x55\x1d\x0f", id.content, 3)) { /* KeyUsage 2.5.29.15 */ const uint8_t *keyusage = value.content; uint8_t usage; have_key_usage = 1; if(value.size < 4 || value.size > 5) { cli_dbgmsg("asn1_get_x509: bad KeyUsage\n"); exts.size = 1; break; } if(!fmap_need_ptr_once(map, value.content, value.size)) { exts.size = 1; break; } if(keyusage[0] != 0x03 || keyusage[1] != value.size - 2 || keyusage[2] > 7) { cli_dbgmsg("asn1_get_x509: bad KeyUsage\n"); exts.size = 1; break; } usage = keyusage[3]; if(value.size == 4) usage &= ~((1 << keyusage[2])-1); x509.certSign = ((usage & 4) != 0); continue; } if(!memcmp("\x55\x1d\x25", id.content, 3)) { /* ExtKeyUsage 2.5.29.37 */ struct cli_asn1 keypurp; have_ext_key = 1; if(asn1_expect_objtype(map, value.content, &value.size, &keypurp, ASN1_TYPE_SEQUENCE)) { exts.size = 1; break; } if(value.size) { cli_dbgmsg("asn1_get_x509: extra data in ExtKeyUsage\n"); exts.size = 1; break; } ext.next = keypurp.content; while(keypurp.size) { if(asn1_expect_objtype(map, ext.next, &keypurp.size, &ext, ASN1_TYPE_OBJECT_ID)) { exts.size = 1; break; } if(ext.size != 8 && ext.size != 10) continue; if(!fmap_need_ptr_once(map, ext.content, ext.size)) { exts.size = 1; break; } if(!memcmp("\x2b\x06\x01\x05\x05\x07\x03\x03", ext.content, 8)) /* id_kp_codeSigning */ x509.codeSign = 1; else if(!memcmp("\x2b\x06\x01\x05\x05\x07\x03\x08", ext.content, 8)) /* id_kp_timeStamping */ x509.timeSign = 1; else if(!memcmp("\x2b\x06\x01\x04\x01\x82\x37\x0a\x03\x0d", ext.content, 10)) /* id_kp_lifetimeSigning */ cli_dbgmsg("asn1_get_x509: lifetime signing specified but enforcing this is not currently supported\n"); } continue; } if(!memcmp("\x55\x1d\x13", id.content, 3)) { /* Basic Constraints 2.5.29.19 */ struct cli_asn1 constr; if(asn1_expect_objtype(map, value.content, &value.size, &constr, ASN1_TYPE_SEQUENCE)) { exts.size = 1; break; } if(!constr.size) x509.certSign = 0; else { if(asn1_expect_objtype(map, constr.content, &constr.size, &ext, ASN1_TYPE_BOOLEAN)) { exts.size = 1; break; } if(ext.size != 1) { cli_dbgmsg("asn1_get_x509: wrong bool size in basic constraint %u\n", ext.size); exts.size = 1; break; } if(!fmap_need_ptr_once(map, ext.content, 1)) { exts.size = 1; break; } x509.certSign = (((uint8_t *)(ext.content))[0] != 0); } } } if(exts.size) { tbs.size = 1; break; } /* The 2008 spec doc says that for a certificate to be used for * code signing, it must either have an EKU indicating code * signing or the entire certificate chain must not have any * EKUs. * TODO We should actually enforce that last check. * For time stamping, the doc says the EKU must be present, and * makes no exception for EKUs being missing. * TODO Should we not set timeSign = 1 in this case, then? */ if(!have_ext_key) x509.codeSign = x509.timeSign = 1; /* RFC 3280 section 4.2.1.3 says that if a certificate is * used to validate digital signatures on other public key * certificates, it MUST have a key usage extension with the * appropriate bits set. However, the MS MD5 root authority * certificate (A43489159A520F0D93D032CCAF37E7FE20A8B419) * doesn't have a KU or any EKUs, and PEs with it in the * chain validate successfully. * TODO Flip the certSign bit for now, but revisit if * a clarification on this becomes available */ if(!have_key_usage) x509.certSign = 1; } } if(tbs.size) { cli_dbgmsg("asn1_get_x509: An error occurred when parsing x509 extensions\n"); break; } if (!x509.certSign && !x509.codeSign && !x509.timeSign) { cli_dbgmsg("asn1_get_x509: encountered a certificate with no cert, code, or time signing capabilities\n"); } if(crtmgr_lookup(crts, &x509)) { cli_dbgmsg("asn1_get_x509: duplicate embedded certificates detected\n"); cli_crt_clear(&x509); return ASN1_GET_X509_SUCCESS; } if(map_raw(map, issuer, issuersize, x509.raw_issuer)) break; if(map_sha1(map, issuer, issuersize, x509.issuer)) break; if(asn1_expect_rsa(map, &tbs.next, &crt.size, &hashtype2)) /* signature algo - Ex: sha1WithRSAEncryption */ break; if(hashtype1 != hashtype2) { cli_dbgmsg("asn1_get_x509: found conflicting RSA hash types\n"); break; } x509.hashtype = hashtype1; if(asn1_expect_objtype(map, tbs.next, &crt.size, &obj, ASN1_TYPE_BIT_STRING)) { /* signature */ cli_dbgmsg("asn1_get_x509: Failed to parse x509 signature BIT STRING\n"); break; } if(obj.size > 513) { cli_dbgmsg("asn1_get_x509: signature too long\n"); break; } if(!fmap_need_ptr_once(map, obj.content, obj.size)) { cli_dbgmsg("asn1_get_x509: cannot read signature\n"); break; } if(mp_read_unsigned_bin(&x509.sig, obj.content, obj.size)) { cli_dbgmsg("asn1_get_x509: cannot convert signature to big number\n"); break; } if(crt.size) { cli_dbgmsg("asn1_get_x509: found unexpected extra data in signature\n"); break; } if(map_hash(map, tbsdata, tbssize, x509.tbshash, x509.hashtype)) { cli_dbgmsg("asn1_get_x509: Unsupported hashtype or hash computation failed\n"); break; } if(crtmgr_add(crts, &x509)) break; cli_crt_clear(&x509); return ASN1_GET_X509_SUCCESS; } while(0); cli_crt_clear(&x509); return ret; } static int asn1_parse_countersignature(fmap_t *map, const void **asn1data, unsigned int *size, crtmgr *cmgr, const uint8_t *message, const unsigned int message_size, time_t not_before, time_t not_after) { struct cli_asn1 asn1, deep, deeper; uint8_t issuer[SHA1_HASH_SIZE], serial[SHA1_HASH_SIZE]; const uint8_t *attrs; unsigned int dsize, attrs_size; unsigned int avail; uint8_t hash[MAX_HASH_SIZE]; cli_crt_hashtype hashtype; cli_crt_hashtype hashtype2; unsigned int hashsize; uint8_t md[MAX_HASH_SIZE]; int result; void *ctx; do { if(asn1_expect_objtype(map, *asn1data, size, &asn1, ASN1_TYPE_SEQUENCE)) { cli_dbgmsg("asn1_parse_countersignature: expected SEQUENCE inside counterSignature SET\n"); break; } avail = asn1.size; if (asn1_expect_objtype(map, asn1.content, &avail, &deep, ASN1_TYPE_INTEGER)) { cli_dbgmsg("asn1_parse_countersignature: expected INTEGER for counterSignature version"); break; } if(deep.size != 1) { cli_dbgmsg("asn1_parse_countersignature: expected INTEGER of size 1, got size %u\n", deep.size); break; } if(!fmap_need_ptr_once(map, deep.content, 1)) { cli_dbgmsg("asn1_parse_countersignature: failed to read version\n"); break; } /* Allow either '0' or '1' for the version. The specification says * that this field must be 1, but some binaries have 0 here and * they appear to validate just fine via the Windows API */ if(memcmp(deep.content, "\x01", 1) && memcmp(deep.content, "\x00", 1)) { cli_dbgmsg("asn1_parse_countersignature: counterSignature version is not 1 or 0\n"); break; } asn1.content = deep.next; if(asn1_expect_objtype(map, asn1.content, &avail, &asn1, ASN1_TYPE_SEQUENCE)) { /* issuerAndSerialNumber */ cli_dbgmsg("asn1_parse_countersignature: unable to parse issuerAndSerialNumber SEQUENCE in counterSignature\n"); break; } if(asn1_expect_objtype(map, asn1.content, &asn1.size, &deep, ASN1_TYPE_SEQUENCE)) { /* issuer */ cli_dbgmsg("asn1_parse_countersignature: unable to parse issuer SEQUENCE in counterSignature\n"); break; } // Compute the hash of the issuer section if(map_sha1(map, deep.content, deep.size, issuer)) { cli_dbgmsg("asn1_parse_countersignature: error in call to map_sha1 for counterSignature issuer\n"); break; } if(asn1_expect_objtype(map, deep.next, &asn1.size, &deep, ASN1_TYPE_INTEGER)) { /* serial */ cli_dbgmsg("asn1_parse_countersignature: expected ASN1_TYPE_INTEGER serial for counterSignature\n"); break; } // Compute the hash of the serial INTEGER if(map_sha1(map, deep.content, deep.size, serial)) { cli_dbgmsg("asn1_parse_countersignature: error in call to map_sha1 for counterSignature serial\n"); break; } if(asn1.size) { cli_dbgmsg("asn1_parse_countersignature: extra data inside counterSignature issuer\n"); break; } if(asn1_expect_hash_algo(map, &asn1.next, &avail, &hashtype, &hashsize)) { cli_dbgmsg("asn1_parse_countersignature: error parsing counterSignature digestAlgorithm\n"); break; } if(map_hash(map, message, message_size, md, hashtype)) { cli_dbgmsg("asn1_parse_countersignature: failed to map in message/compute countersignature hash\n"); break; } attrs = asn1.next; if(asn1_expect_objtype(map, asn1.next, &avail, &asn1, 0xa0)) { /* authenticatedAttributes */ cli_dbgmsg("asn1_parse_countersignature: unable to parse counterSignature authenticatedAttributes section\n"); break; } attrs_size = (uint8_t *)(asn1.next) - attrs; if(asn1.next == NULL && attrs_size < 2) { cli_dbgmsg("asn1_parse_countersignature: counterSignature authenticatedAttributes are too small\n"); break; } result = 0; dsize = asn1.size; deep.next = asn1.content; while(dsize) { int content; if(asn1_expect_objtype(map, deep.next, &dsize, &deep, ASN1_TYPE_SEQUENCE)) { /* attribute */ cli_dbgmsg("asn1_parse_countersignature: expected counterSignature attribute SEQUENCE\n"); dsize = 1; break; } if(asn1_expect_objtype(map, deep.content, &deep.size, &deeper, ASN1_TYPE_OBJECT_ID)) { /* attribute type */ cli_dbgmsg("asn1_parse_countersignature: expected attribute type inside counterSignature attribute SEQUENCE\n"); dsize = 1; break; } if(deeper.size != lenof(OID_contentType)) /* lenof(contentType) = lenof(messageDigest) = lenof(signingTime) = 9 */ continue; if(!fmap_need_ptr_once(map, deeper.content, lenof(OID_contentType))) { cli_dbgmsg("asn1_parse_countersignature: failed to read counterSignature authenticated attribute\n"); dsize = 1; break; } if(!memcmp(deeper.content, OID_contentType, lenof(OID_contentType))) content = 0; /* contentType */ else if(!memcmp(deeper.content, OID_messageDigest, lenof(OID_messageDigest))) content = 1; /* messageDigest */ else if(!memcmp(deeper.content, OID_signingTime, lenof(OID_signingTime))) content = 2; /* signingTime */ else continue; if(result & (1< not_after) { cli_dbgmsg("asn1_parse_countersignature: countersignature timestamp outside cert validity\n"); deep.size = 1; } break; } } if(deep.size) { dsize = 1; break; } } if(dsize) break; if(result != 7) { cli_dbgmsg("asn1_parse_countersignature: some important attributes are missing in countersignature\n"); break; } // TODO For some reason there tends to be more variability here than // when parsing the regular signature - we have to support at least // szOID_RSA_RSA and szOID_RSA_SHA1RSA based on samples seen in the // wild. The spec says this should only be the RSA and DSA OIDs, // though. if (asn1_expect_rsa(map, &asn1.next, &avail, &hashtype2)) { cli_dbgmsg("asn1_parse_countersignature: unable to parse the digestEncryptionAlgorithm\n"); break; } if (hashtype2 != CLI_RSA && hashtype2 != hashtype) { cli_dbgmsg("asn1_parse_countersignature: digestEncryptionAlgorithm conflicts with digestAlgorithm\n"); break; } if(asn1_expect_objtype(map, asn1.next, &avail, &asn1, ASN1_TYPE_OCTET_STRING)) { /* encryptedDigest */ cli_dbgmsg("asn1_parse_countersignature: unexpected encryptedDigest value in counterSignature\n"); break; } if(asn1.size > 513) { cli_dbgmsg("asn1_parse_countersignature: countersignature encryptedDigest too long\n"); break; } if(avail) { cli_dbgmsg("asn1_parse_countersignature: extra data inside countersignature\n"); break; } if(!fmap_need_ptr_once(map, attrs, attrs_size)) { cli_dbgmsg("asn1_parse_countersignature: failed to read authenticatedAttributes\n"); break; } if (NULL == (ctx = get_hash_ctx(hashtype))) { break; } cl_update_hash(ctx, "\x31", 1); cl_update_hash(ctx, (void *)(attrs + 1), attrs_size - 1); cl_finish_hash(ctx, hash); if(!fmap_need_ptr_once(map, asn1.content, asn1.size)) { cli_dbgmsg("asn1_parse_countersignature: failed to read countersignature encryptedDigest\n"); break; } if(!crtmgr_verify_pkcs7(cmgr, issuer, serial, asn1.content, asn1.size, hashtype, hash, VRFY_TIME)) { cli_dbgmsg("asn1_parse_countersignature: pkcs7 countersignature verification failed\n"); break; } cli_dbgmsg("asn1_parse_countersignature: countersignature verification completed successfully\n"); return 0; } while(0); return 1; } static cl_error_t asn1_parse_mscat(fmap_t *map, size_t offset, unsigned int size, crtmgr *cmgr, int embedded, const void **hashes, unsigned int *hashes_size, struct cl_engine *engine) { struct cli_asn1 asn1, deep, deeper; uint8_t issuer[SHA1_HASH_SIZE], serial[SHA1_HASH_SIZE]; const uint8_t *message, *attrs; unsigned int dsize, message_size, attrs_size; // hash is used to hold the hashes we compute as part of sig verification uint8_t hash[MAX_HASH_SIZE]; cli_crt_hashtype hashtype, hashtype2; unsigned int hashsize; // md is used to hold the message digest we extract from the signature uint8_t md[MAX_HASH_SIZE]; cli_crt *x509; void *ctx; int result; cl_error_t ret = CL_EPARSE; cli_dbgmsg("in asn1_parse_mscat\n"); do { if(!(message = fmap_need_off_once(map, offset, 1))) { cli_dbgmsg("asn1_parse_mscat: failed to read pkcs#7 entry\n"); break; } if(asn1_expect_objtype(map, message, &size, &asn1, ASN1_TYPE_SEQUENCE)){ /* SEQUENCE */ cli_dbgmsg("asn1_parse_mscat: expected SEQUENCE at top level\n"); break; } // Many signatures have zero bytes at the end (padding?) /* if(size) { */ /* cli_dbgmsg("asn1_parse_mscat: found extra data after pkcs#7 %u\n", size); */ /* break; */ /* } */ size = asn1.size; if(asn1_expect_obj(map, &asn1.content, &size, ASN1_TYPE_OBJECT_ID, lenof(OID_signedData), OID_signedData)){ /* OBJECT 1.2.840.113549.1.7.2 - contentType = signedData */ cli_dbgmsg("asn1_parse_mscat: expected contentType == signedData\n"); break; } if(asn1_expect_objtype(map, asn1.content, &size, &asn1, 0xa0)){ /* [0] - content */ cli_dbgmsg("asn1_parse_mscat: expected '[0] - content' following signedData contentType\n"); break; } if(size) { cli_dbgmsg("asn1_parse_mscat: found extra data in pkcs#7\n"); break; } size = asn1.size; if(asn1_expect_objtype(map, asn1.content, &size, &asn1, ASN1_TYPE_SEQUENCE)){ /* SEQUENCE */ cli_dbgmsg("asn1_parse_mscat: expected SEQUENCE inside signedData '[0] - content'\n"); break; } if(size) { cli_dbgmsg("asn1_parse_mscat: found extra data in signedData\n"); break; } size = asn1.size; if(asn1_expect_obj(map, &asn1.content, &size, ASN1_TYPE_INTEGER, 1, "\x01")){ /* INTEGER - VERSION 1 */ cli_dbgmsg("asn1_parse_mscat: expected 'INTEGER - VERSION 1' for signedData version\n"); break; } if(asn1_expect_objtype(map, asn1.content, &size, &asn1, ASN1_TYPE_SET)){ /* SET OF DigestAlgorithmIdentifier */ cli_dbgmsg("asn1_parse_mscat: expected SET OF DigestAlgorithmIdentifier inside signedData\n"); break; } // At this point asn1.next points to the SEQUENCE following the // DigestAlgorithmIdentifier SET, so we'll want to preserve it so // we can continue parsing laterally. We also want to preserve // size, since it tracks how much is left in the SignedData section. if (asn1_expect_hash_algo(map, &asn1.content, &asn1.size, &hashtype, &hashsize)) { cli_dbgmsg("asn1_parse_mscat: error parsing SignedData digestAlgorithm\n"); break; } if (asn1.size) { cli_dbgmsg("asn1_parse_mscat: found extra data in the SignerData digestAlgorithm SET\n"); break; } // We've finished parsing the DigestAlgorithmIdentifiers SET, so start // back parsing the SignedData if(asn1_expect_objtype(map, asn1.next, &size, &asn1, ASN1_TYPE_SEQUENCE)){ /* SEQUENCE - contentInfo */ cli_dbgmsg("asn1_parse_mscat: expected 'SEQUENCE - contentInfo' inside SignedData following DigestAlgorithmIdentifiers\n"); break; } // Parse the contentInfo SEQUENCE. asn1.next and size point to the // certificates, so these need to be preserved /* Here there is either a PKCS #7 ContentType Object Identifier for Certificate Trust List (szOID_CTL) * or a single SPC_INDIRECT_DATA_OBJID */ if( (!embedded && asn1_expect_obj(map, &asn1.content, &asn1.size, ASN1_TYPE_OBJECT_ID, lenof(OID_szOID_CTL), OID_szOID_CTL)) || (embedded && asn1_expect_obj(map, &asn1.content, &asn1.size, ASN1_TYPE_OBJECT_ID, lenof(OID_SPC_INDIRECT_DATA_OBJID), OID_SPC_INDIRECT_DATA_OBJID)) ){ cli_dbgmsg("asn1_parse_mscat: unexpected ContentType for embedded mode %d\n", embedded); break; } if(asn1_expect_objtype(map, asn1.content, &asn1.size, &deep, 0xa0)){ cli_dbgmsg("asn1_parse_mscat: expected '[0] - content' following DigestAlgorithmIdentifier contentType\n"); break; } if(asn1.size) { cli_dbgmsg("asn1_parse_mscat: found extra data in contentInfo\n"); break; } dsize = deep.size; if(asn1_expect_objtype(map, deep.content, &dsize, &deep, ASN1_TYPE_SEQUENCE)) { cli_dbgmsg("asn1_parse_mscat: expected SEQUENCE in DigestAlgorithmIdentifier '[0] - contentInfo'\n"); break; } if(dsize) { cli_dbgmsg("asn1_parse_mscat: found extra data in content\n"); break; } /* * Hashes should look like: * SEQUENCE(2 elem) * OBJECT IDENTIFIER 1.3.6.1.4.1.311.2.1.15 spcPEImageData * SEQUENCE(2 elem) * BIT STRING(0 elem) * [0](1 elem) * [2](1 elem) * [0] * SEQUENCE(2 elem) * SEQUENCE(2 elem) * OBJECT IDENTIFIER 1.3.14.3.2.26 sha1 (OIW) * NULL * OCTET STRING(20 byte) */ *hashes = deep.content; *hashes_size = deep.size; // Now resume parsing SignedData - certificates if(asn1_expect_objtype(map, asn1.next, &size, &asn1, 0xa0)){ /* certificates */ cli_dbgmsg("asn1_parse_mscat: expected 0xa0 certificates entry\n"); break; } dsize = asn1.size; if(dsize) { crtmgr newcerts; crtmgr_init(&newcerts); while(dsize) { result = asn1_get_x509(map, &asn1.content, &dsize, &newcerts); if(ASN1_GET_X509_UNRECOVERABLE_ERROR == result) { dsize = 1; break; } else if(ASN1_GET_X509_CERT_ERROR == result) { cli_dbgmsg("asn1_parse_mscat: skipping x509 certificate with errors\n"); } } if(dsize) { crtmgr_free(&newcerts); cli_dbgmsg("asn1_parse_mscat: an unrecoverable error occurred while extracting x509 certificates\n"); break; } if(newcerts.crts) { x509 = newcerts.crts; cli_dbgmsg("asn1_parse_mscat: %u embedded certificates collected\n", newcerts.items); if (engine->engine_options & ENGINE_OPTIONS_PE_DUMPCERTS) { /* Dump the certs if requested before anything happens to them */ while(x509) { char raw_issuer[CRT_RAWMAXLEN*2+1], raw_subject[CRT_RAWMAXLEN*2+1], raw_serial[CRT_RAWMAXLEN*3+1]; char issuer[SHA1_HASH_SIZE*2+1], subject[SHA1_HASH_SIZE*2+1], serial[SHA1_HASH_SIZE*2+1]; char mod[1024+1], exp[1024+1]; int j=1024; fp_toradix_n(&x509->n, mod, 16, j+1); fp_toradix_n(&x509->e, exp, 16, j+1); memset(raw_issuer, 0, CRT_RAWMAXLEN*2+1); memset(raw_subject, 0, CRT_RAWMAXLEN*2+1); memset(raw_serial, 0, CRT_RAWMAXLEN*2+1); for (j=0; j < x509->raw_issuer[0]; j++) sprintf(&raw_issuer[j*2], "%02x", x509->raw_issuer[j+1]); for (j=0; j < x509->raw_subject[0]; j++) sprintf(&raw_subject[j*2], "%02x", x509->raw_subject[j+1]); for (j=0; j < x509->raw_serial[0]; j++) sprintf(&raw_serial[j*3], "%02x%c", x509->raw_serial[j+1], (j != x509->raw_serial[0]-1) ? ':' : '\0'); for (j=0; j < SHA1_HASH_SIZE; j++) { sprintf(&issuer[j*2], "%02x", x509->issuer[j]); sprintf(&subject[j*2], "%02x", x509->subject[j]); sprintf(&serial[j*2], "%02x", x509->serial[j]); } cli_dbgmsg_internal("cert:\n"); cli_dbgmsg_internal(" subject: %s\n", subject); cli_dbgmsg_internal(" serial: %s\n", serial); cli_dbgmsg_internal(" pubkey: %s\n", mod); cli_dbgmsg_internal(" i: %s %lu->%lu %s%s%s\n", issuer, (unsigned long)x509->not_before, (unsigned long)x509->not_after, x509->codeSign ? "code " : "", x509->timeSign ? "time " : "", x509->certSign ? "cert " : ""); cli_dbgmsg_internal(" ==============RAW==============\n"); cli_dbgmsg_internal(" raw_subject: %s\n", raw_subject); cli_dbgmsg_internal(" raw_serial: %s\n", raw_serial); cli_dbgmsg_internal(" raw_issuer: %s\n", raw_issuer); x509 = x509->next; } x509 = newcerts.crts; } while(x509) { cli_crt *parent; /* If the certificate is in the trust store already, remove * it from the newcerts list */ if (crtmgr_lookup(cmgr, x509)) { cli_crt *tmp = x509->next; cli_dbgmsg("asn1_parse_mscat: found embedded certificate matching one in the trust store\n"); crtmgr_del(&newcerts, x509); x509 = tmp; continue; } /* Determine whether the cert is signed by one in our trust * store or has a blacklist entry */ parent = crtmgr_verify_crt(cmgr, x509); if(parent) { if (parent->isBlacklisted) { // NOTE: In this case, parent is a blacklist entry // in cmgr for this certificate, not a blacklist // entry for this certificate's parent ret = CL_VIRUS; cli_dbgmsg("asn1_parse_mscat: Authenticode certificate %s is revoked. Flagging sample as virus.\n", (parent->name ? parent->name : "(no name)")); crtmgr_free(&newcerts); goto finish; } // TODO Why is this done? x509->codeSign &= parent->codeSign; x509->timeSign &= parent->timeSign; if(crtmgr_add(cmgr, x509)) { cli_dbgmsg("asn1_parse_mscat: adding x509 cert to crtmgr failed\n"); break; } crtmgr_del(&newcerts, x509); /* Start at the beginning of newcerts so that we can see * whether adding this new trusted cert causes more * certs to be trusted (via chaining). Otherwise we * might miss valid certs if the ordering in the binary * doesn't align with the chain ordering. */ x509 = newcerts.crts; continue; } x509 = x509->next; } if(x509) { crtmgr_free(&newcerts); break; } if(newcerts.items) cli_dbgmsg("asn1_parse_mscat: %u certificates did not verify\n", newcerts.items); crtmgr_free(&newcerts); } } // Parse the final section in SignedData - SignerInfos if(asn1_get_obj(map, asn1.next, &size, &asn1)) { cli_dbgmsg("asn1_parse_mscat: failed to get next ASN1 section\n"); break; } if(asn1.type == 0xa1 && asn1_get_obj(map, asn1.next, &size, &asn1)){ /* crls - unused shouldn't be present */ cli_dbgmsg("asn1_parse_mscat: unexpected CRL entries were found\n"); break; } if(asn1.type != ASN1_TYPE_SET) { /* signerInfos */ cli_dbgmsg("asn1_parse_mscat: unexpected type %02x for signerInfo\n", asn1.type); break; } if(size) { cli_dbgmsg("asn1_parse_mscat: unexpected extra data after signerInfos\n"); break; } size = asn1.size; if(asn1_expect_objtype(map, asn1.content, &size, &asn1, ASN1_TYPE_SEQUENCE)) { cli_dbgmsg("asn1_parse_mscat: expected SEQUENCE in signerInfos"); break; } if(size) { cli_dbgmsg("asn1_parse_mscat: only one signerInfo shall be present\n"); break; } size = asn1.size; if(asn1_expect_obj(map, &asn1.content, &size, ASN1_TYPE_INTEGER, 1, "\x01")){ /* Version = 1 */ cli_dbgmsg("asn1_parse_mscat: expected Version == 1 for signerInfo\n"); break; } if(asn1_expect_objtype(map, asn1.content, &size, &asn1, ASN1_TYPE_SEQUENCE)){ /* issuerAndSerialNumber */ cli_dbgmsg("asn1_parse_mscat: expected issuerAndSerialNumber SEQUENCE\n"); break; } // asn1.next and size must be preserved so we can continue parsing // SignerInfos, so switch to deep dsize = asn1.size; if(asn1_expect_objtype(map, asn1.content, &dsize, &deep, ASN1_TYPE_SEQUENCE)){ /* issuer */ cli_dbgmsg("asn1_parse_mscat: expected issuer SEQUENCE\n"); break; } /* Make sure the issuer ID is mapped into memory and then compute the * SHA1 of it so we can use this value in verification later on. This * will be a hash over all the values in the issuer SEQUENCE, which * looks something like: * SET(1 elem) * SEQUENCE(2 elem) * OBJECT IDENTIFIER 2.5.4.6 countryName (X.520 DN component) * PrintableString * SET(1 elem) * SEQUENCE(2 elem) * OBJECT IDENTIFIER2.5.4.8 stateOrProvinceName (X.520 DN component) * PrintableString * SET(1 elem) * SEQUENCE(2 elem) * OBJECT IDENTIFIER2.5.4.7 localityName (X.520 DN component) * PrintableString * SET(1 elem) * SEQUENCE(2 elem) * OBJECT IDENTIFIER2.5.4.10 organizationName (X.520 DN component) * PrintableString * SET(1 elem) * SEQUENCE(2 elem) * OBJECT IDENTIFIER2.5.4.3commonName(X.520 DN component) * PrintableString */ if(map_sha1(map, deep.content, deep.size, issuer)){ cli_dbgmsg("asn1_parse_mscat: error in call to map_sha1 for issuer\n"); break; } if(asn1_expect_objtype(map, deep.next, &dsize, &deep, ASN1_TYPE_INTEGER)){ /* serial */ cli_dbgmsg("asn1_parse_mscat: expected ASN1_TYPE_INTEGER serial\n"); break; } /* Make sure the serial INTEGER is mapped into memory and compute the * SHA1 of it so we can use this value in verification later on. */ if(map_sha1(map, deep.content, deep.size, serial)){ cli_dbgmsg("asn1_parse_mscat: error in call to map_sha1 for serial\n"); break; } if(dsize) { cli_dbgmsg("asn1_parse_mscat: extra data inside issuerAndSerialNumber\n"); break; } // Resume parsing the SignerInfos using asn1.next and size if (asn1_expect_hash_algo(map, &asn1.next, &size, &hashtype2, &hashsize)) { cli_dbgmsg("asn1_parse_mscat: error parsing SignerInfo digestAlgorithm\n"); break; } // Verify that the SignerInfo digestAlgorithm matches the one from the SignedData section if (hashtype != hashtype2) { cli_dbgmsg("asn1_parse_mscat: SignerInfo digestAlgorithm is not the same as the algorithm in SignedData\n"); break; } // Continue on to the authenticatedAttributes section within SignerInfo attrs = asn1.next; if(asn1_expect_objtype(map, asn1.next, &size, &asn1, 0xa0)){ /* authenticatedAttributes */ cli_dbgmsg("asn1_parse_mscat: unable to parse authenticatedAttributes section\n"); break; } attrs_size = (uint8_t *)(asn1.next) - attrs; if(asn1.next == NULL || attrs_size < 2) { cli_dbgmsg("asn1_parse_mscat: authenticatedAttributes size is too small\n"); break; } dsize = asn1.size; deep.next = asn1.content; result = 0; while(dsize) { struct cli_asn1 cobj; int content; if(asn1_expect_objtype(map, deep.next, &dsize, &deep, ASN1_TYPE_SEQUENCE)) { /* attribute */ cli_dbgmsg("asn1_parse_mscat: expected attribute SEQUENCE\n"); dsize = 1; break; } if(asn1_expect_objtype(map, deep.content, &deep.size, &deeper, ASN1_TYPE_OBJECT_ID)) { /* attribute type */ cli_dbgmsg("asn1_parse_mscat: expected attribute type inside attribute SEQUENCE\n"); dsize = 1; break; } if(deeper.size != lenof(OID_contentType)) continue; if(!fmap_need_ptr_once(map, deeper.content, lenof(OID_contentType))) { cli_dbgmsg("asn1_parse_mscat: failed to read authenticated attribute\n"); dsize = 1; break; } if(!memcmp(deeper.content, OID_contentType, lenof(OID_contentType))) content = 0; /* contentType */ else if(!memcmp(deeper.content, OID_messageDigest, lenof(OID_messageDigest))) content = 1; /* messageDigest */ else continue; if(asn1_expect_objtype(map, deeper.next, &deep.size, &deeper, ASN1_TYPE_SET)) { /* set - contents */ cli_dbgmsg("asn1_parse_mscat: expected 'set - contents' for authenticated attribute\n"); dsize = 1; break; } if(deep.size) { cli_dbgmsg("asn1_parse_mscat: extra data in authenticated attributes\n"); dsize = 1; break; } if(result & (1< 513) { cli_dbgmsg("asn1_parse_mscat: encryptedDigest too long\n"); break; } if(map_hash(map, *hashes, *hashes_size, hash, hashtype)) { cli_dbgmsg("asn1_parse_mscat: failed to map in message/compute message digest\n"); break; } if(memcmp(hash, md, hashsize)) { cli_dbgmsg("asn1_parse_mscat: messageDigest mismatch\n"); break; } if(!fmap_need_ptr_once(map, attrs, attrs_size)) { cli_dbgmsg("asn1_parse_mscat: failed to read authenticatedAttributes\n"); break; } if (NULL == (ctx = get_hash_ctx(hashtype))) { break; } cl_update_hash(ctx, "\x31", 1); cl_update_hash(ctx, (void *)(attrs + 1), attrs_size - 1); cl_finish_hash(ctx, hash); if(!fmap_need_ptr_once(map, asn1.content, asn1.size)) { cli_dbgmsg("asn1_parse_mscat: failed to read encryptedDigest\n"); break; } // Verify the authenticatedAttributes if(!(x509 = crtmgr_verify_pkcs7(cmgr, issuer, serial, asn1.content, asn1.size, hashtype, hash, VRFY_CODE))) { cli_dbgmsg("asn1_parse_mscat: pkcs7 signature verification failed\n"); ret = CL_EVERIFY; break; } message = asn1.content; message_size = asn1.size; cli_dbgmsg("asn1_parse_mscat: authenticatedAttributes successfully parsed and verified\n"); /* We need to verify the time validity of the certificate. If a * signature has a time-stamping countersignature, then we just need to * verify that countersignature. Otherwise, we should determine * whether the signing certificate is still valid (time-based, since at * this point in the code no matching blacklist rules fired). */ if(!size) { time_t now; // No countersignature, so judge validity based on time now = time(NULL); if(now < x509->not_before || now > x509->not_after) { cli_dbgmsg("asn1_parse_mscat: no countersignature (unauthAttrs missing) and signing certificate has expired\n"); ret = CL_EVERIFY; break; } cli_dbgmsg("asn1_parse_mscat: no countersignature (unauthAttrs missing) but the signing certificate is still valid\n"); ret = CL_CLEAN; goto finish; } if(size && asn1_expect_objtype(map, asn1.next, &size, &asn1, 0xa1)) { /* unauthenticatedAttributes */ cli_dbgmsg("asn1_parse_mscat: unable to find unauthenticatedAttributes section\n"); break; } if(size) { cli_dbgmsg("asn1_parse_mscat: extra data inside signerInfo\n"); break; } // Parse the unauthenticated attributes dsize = asn1.size; deep.next = asn1.content; result = 0; while(dsize) { int content; if(asn1_expect_objtype(map, deep.next, &dsize, &deep, ASN1_TYPE_SEQUENCE)) { cli_dbgmsg("asn1_parse_mscat: expected SEQUENCE starting an unauthenticatedAttribute\n"); dsize = 1; break; } if(asn1_expect_objtype(map, deep.content, &deep.size, &deeper, ASN1_TYPE_OBJECT_ID)) { cli_dbgmsg("asn1_parse_mscat: expected OID inside unauthenticatedAttribute SEQUENCE\n"); dsize = 1; break; } // Supported OIDs include: // - 1.2.840.113549.1.9.6 - counterSignature // - 1.3.6.1.4.1.311.2.4.1 - nested signatures // I've seen some other ones like 1.3.6.1.4.1.3845.3.9876.1.1.1, // and the presence of those doesn't seem to mess up verification // through the Windows API, so just skip those if(deeper.size != lenof(OID_countersignature) && deeper.size != lenof(OID_nestedSignatures)) { continue; } if(!fmap_need_ptr_once(map, deeper.content, deeper.size)) { cli_dbgmsg("asn1_parse_mscat: failed to read unauthenticated attribute OID\n"); dsize = 1; break; } if(!memcmp(deeper.content, OID_countersignature, deeper.size)) content = 0; /* counterSignature */ else if(!memcmp(deeper.content, OID_nestedSignatures, deeper.size)) content = 1; /* nested */ else { continue; } if(asn1_expect_objtype(map, deeper.next, &deep.size, &deeper, ASN1_TYPE_SET)) { /* set - contents */ cli_dbgmsg("asn1_parse_mscat: expected 'set - contents' inside unauthenticated attribute\n"); dsize = 1; break; } if(deep.size) { cli_dbgmsg("asn1_parse_mscat: extra data in unauthenticated attribute\n"); dsize = 1; break; } if(result & (1<not_before, x509->not_after)) { dsize = 1; break; } result |= 1; } else { /* nestedSignature */ // TODO Support parsing these out in the future cli_dbgmsg("asn1_parse_mscat: nested signatures detected but parsing them is not currently supported\n"); deeper.size = 0; result |= 2; } if(deeper.size) { cli_dbgmsg("asn1_parse_mscat: extra data in unauthenticated attribute\n"); dsize = 1; break; } } if(dsize) break; cli_dbgmsg("asn1_parse_mscat: unauthenticatedAttributes successfully parsed\n"); if (1 != (result & 1)) { time_t now; // No countersignature, so judge validity based on time now = time(NULL); if(now < x509->not_before || now > x509->not_after) { cli_dbgmsg("asn1_parse_mscat: no countersignature and signing certificate has expired\n"); ret = CL_EVERIFY; break; } cli_dbgmsg("asn1_parse_mscat: no countersignature but the signing certificate is still valid\n"); } ret = CL_CLEAN; } while(0); finish: if (CL_EPARSE == ret) { cli_dbgmsg("asn1_parse_mscat: failed to parse authenticode section\n"); } return ret; } int asn1_load_mscat(fmap_t *map, struct cl_engine *engine) { struct cli_asn1 c; unsigned int size; struct cli_matcher *db; int i; // TODO As currently implemented, loading in a .cat file with -d requires // an accompanying .crb with whitelist entries that will cause the .cat // file signatures to verify successfully. If a user is specifying a .cat // file to use, though, we should assume they trust it and at least add the // covered hashes from it to hm_fp // TODO Since we pass engine->cmgr directly here, the whole chain of trust // for this .cat file will get added to the global trust store assuming it // verifies successfully. Is this a bug for a feature? if(CL_CLEAN != asn1_parse_mscat(map, 0, map->len, &engine->cmgr, 0, &c.next, &size, engine)) return 1; if(asn1_expect_objtype(map, c.next, &size, &c, ASN1_TYPE_SEQUENCE)) return 1; if(asn1_expect_obj(map, &c.content, &c.size, ASN1_TYPE_OBJECT_ID, lenof(OID_szOID_CATALOG_LIST), OID_szOID_CATALOG_LIST)) return 1; if(c.size) { cli_dbgmsg("asn1_load_mscat: found extra data in szOID_CATALOG_LIST content\n"); return 1; } if(asn1_expect_objtype(map, c.next, &size, &c, 0x4)) /* List ID */ return 1; if(asn1_expect_objtype(map, c.next, &size, &c, 0x17)) /* Effective date - WTF?! */ return 1; if(asn1_expect_algo(map, &c.next, &size, lenof(OID_szOID_CATALOG_LIST_MEMBER), OID_szOID_CATALOG_LIST_MEMBER)) /* szOID_CATALOG_LIST_MEMBER */ return 1; if(asn1_expect_objtype(map, c.next, &size, &c, ASN1_TYPE_SEQUENCE)) /* hashes here */ return 1; /* [0] is next but we don't care as it's really descriptives stuff */ size = c.size; c.next = c.content; while(size) { struct cli_asn1 tag; if(asn1_expect_objtype(map, c.next, &size, &c, ASN1_TYPE_SEQUENCE)) return 1; if(asn1_expect_objtype(map, c.content, &c.size, &tag, ASN1_TYPE_OCTET_STRING)) /* TAG NAME */ return 1; if(asn1_expect_objtype(map, tag.next, &c.size, &tag, ASN1_TYPE_SET)) /* set */ return 1; if(c.size) { cli_dbgmsg("asn1_load_mscat: found extra data in tag\n"); return 1; } while(tag.size) { struct cli_asn1 tagval1, tagval2, tagval3; int hashtype; if(asn1_expect_objtype(map, tag.content, &tag.size, &tagval1, ASN1_TYPE_SEQUENCE)) return 1; tag.content = tagval1.next; if(asn1_expect_objtype(map, tagval1.content, &tagval1.size, &tagval2, ASN1_TYPE_OBJECT_ID)) return 1; if(tagval2.size != lenof(OID_SPC_INDIRECT_DATA_OBJID)) continue; if(!fmap_need_ptr_once(map, tagval2.content, lenof(OID_SPC_INDIRECT_DATA_OBJID))) { cli_dbgmsg("asn1_load_mscat: cannot read SPC_INDIRECT_DATA\n"); return 1; } if(memcmp(tagval2.content, OID_SPC_INDIRECT_DATA_OBJID, lenof(OID_SPC_INDIRECT_DATA_OBJID))) continue; /* stuff like CAT_NAMEVALUE_OBJID(1.3.6.1.4.1.311.12.2.1) and CAT_MEMBERINFO_OBJID(.2).. */ if(asn1_expect_objtype(map, tagval2.next, &tagval1.size, &tagval2, ASN1_TYPE_SET)) return 1; if(tagval1.size) { cli_dbgmsg("asn1_load_mscat: found extra data in tag value\n"); return 1; } if(asn1_expect_objtype(map, tagval2.content, &tagval2.size, &tagval1, ASN1_TYPE_SEQUENCE)) return 1; if(tagval2.size) { cli_dbgmsg("asn1_load_mscat: found extra data in SPC_INDIRECT_DATA_OBJID tag\n"); return 1; } if(asn1_expect_objtype(map, tagval1.content, &tagval1.size, &tagval2, ASN1_TYPE_SEQUENCE)) return 1; if(asn1_expect_objtype(map, tagval2.content, &tagval2.size, &tagval3, ASN1_TYPE_OBJECT_ID)) /* shall have an obj 1.3.6.1.4.1.311.2.1.15 or 1.3.6.1.4.1.311.2.1.25 inside */ return 1; if(tagval3.size != lenof(OID_SPC_PE_IMAGE_DATA_OBJID)) { /* lenof(OID_SPC_PE_IMAGE_DATA_OBJID) = lenof(OID_SPC_CAB_DATA_OBJID) = 10*/ cli_dbgmsg("asn1_load_mscat: bad hash type size\n"); return 1; } if(!fmap_need_ptr_once(map, tagval3.content, lenof(OID_SPC_PE_IMAGE_DATA_OBJID))) { cli_dbgmsg("asn1_load_mscat: cannot read hash type\n"); return 1; } if(!memcmp(tagval3.content, OID_SPC_PE_IMAGE_DATA_OBJID, lenof(OID_SPC_PE_IMAGE_DATA_OBJID))) hashtype = 2; else if(!memcmp(tagval3.content, OID_SPC_CAB_DATA_OBJID, lenof(OID_SPC_CAB_DATA_OBJID))) hashtype = 1; else { cli_dbgmsg("asn1_load_mscat: unexpected hash type\n"); return 1; } if(asn1_expect_objtype(map, tagval2.next, &tagval1.size, &tagval2, ASN1_TYPE_SEQUENCE)) return 1; if(tagval1.size) { cli_dbgmsg("asn1_load_mscat: found extra data after hash\n"); return 1; } if(asn1_expect_algo(map, &tagval2.content, &tagval2.size, lenof(OID_sha1), OID_sha1)) { /* objid 1.3.14.3.2.26 - sha1 */ cli_dbgmsg("asn1_load_mscat: currently only SHA1 hashes are supported for .cat file signatures\n"); return 1; } if(asn1_expect_objtype(map, tagval2.content, &tagval2.size, &tagval3, ASN1_TYPE_OCTET_STRING)) return 1; if(tagval2.size) { cli_dbgmsg("asn1_load_mscat: found extra data in hash\n"); return 1; } if(tagval3.size != SHA1_HASH_SIZE) { cli_dbgmsg("asn1_load_mscat: bad hash size %u\n", tagval3.size); return 1; } if(!fmap_need_ptr_once(map, tagval3.content, SHA1_HASH_SIZE)) { cli_dbgmsg("asn1_load_mscat: cannot read hash\n"); return 1; } if(cli_debug_flag) { char sha1[SHA1_HASH_SIZE*2+1]; for(i=0;ihm_fp) { if(!(engine->hm_fp = mpool_calloc(engine->mempool, 1, sizeof(*db)))) { tag.size = 1;; return 1; } #ifdef USE_MPOOL engine->hm_fp->mempool = engine->mempool; #endif } if(hm_addhash_bin(engine->hm_fp, tagval3.content, CLI_HASH_SHA1, hashtype, NULL)) { cli_warnmsg("asn1_load_mscat: failed to add hash\n"); return 1; } } } return 0; } /* Check an embedded PE Authenticode section to determine whether it's trusted. * This will return CL_CLEAN if the file should be trusted, CL_EPARSE if an * error occurred while parsing the signature, CL_EVERIFY if parsing was * successful but there were no whitelist rules for the signature, and * CL_VIRUS if a blacklist rule was found for an embedded certificate. */ cl_error_t asn1_check_mscat(struct cl_engine *engine, fmap_t *map, size_t offset, unsigned int size, struct cli_mapped_region *regions, uint32_t nregions) { unsigned int content_size; struct cli_asn1 c; cli_crt_hashtype hashtype; uint8_t hash[MAX_HASH_SIZE]; unsigned int hashsize; const void *content; crtmgr certs; int ret; void *ctx; unsigned int i; // TODO Move these into cli_checkfp_pe if (!(engine->dconf->pe & PE_CONF_CERTS)) return CL_EVERIFY; if (engine->engine_options & ENGINE_OPTIONS_DISABLE_PE_CERTS) return CL_EVERIFY; cli_dbgmsg("in asn1_check_mscat (offset: %llu)\n", (long long unsigned)offset); crtmgr_init(&certs); if(crtmgr_add_roots(engine, &certs)) { crtmgr_free(&certs); return CL_EVERIFY; } ret = asn1_parse_mscat(map, offset, size, &certs, 1, &content, &content_size, engine); crtmgr_free(&certs); if(CL_CLEAN != ret) return ret; if(asn1_expect_objtype(map, content, &content_size, &c, ASN1_TYPE_SEQUENCE)) { cli_dbgmsg("asn1_check_mscat: expected SEQUENCE at top level of hash container\n"); return CL_EPARSE; } if(asn1_expect_obj(map, &c.content, &c.size, ASN1_TYPE_OBJECT_ID, lenof(OID_SPC_PE_IMAGE_DATA_OBJID), OID_SPC_PE_IMAGE_DATA_OBJID)) { cli_dbgmsg("asn1_check_mscat: expected spcPEImageData OID in the first hash SEQUENCE\n"); return CL_EPARSE; } // TODO Should we do anything with the underlying SEQUENCE and data? From // the 2008 spec doc it doesn't sound like many of the fields are used, so // ignoring is probably fine for now if(asn1_expect_objtype(map, c.next, &content_size, &c, ASN1_TYPE_SEQUENCE)) { cli_dbgmsg("asn1_check_mscat: expected second hash container object to be a SEQUENCE\n"); return CL_EPARSE; } if(content_size) { cli_dbgmsg("asn1_check_mscat: extra data in hash SEQUENCE\n"); return CL_EPARSE; } if(asn1_expect_hash_algo(map, &c.content, &c.size, &hashtype, &hashsize)) { cli_dbgmsg("asn1_check_mscat: unexpected file hash algo\n"); return CL_EPARSE; } if (NULL == (ctx = get_hash_ctx(hashtype))) { return CL_EPARSE; } // Now that we know the hash algorithm, compute the authenticode hash // across the required regions of memory. for(i = 0; i < nregions; i++) { const uint8_t *hptr; if (0 == regions[i].size) { continue; } if(!(hptr = fmap_need_off_once(map, regions[i].offset, regions[i].size))){ return CL_EVERIFY; } cl_update_hash(ctx, hptr, regions[i].size); } cl_finish_hash(ctx, hash); if(cli_debug_flag) { char hashtxt[MAX_HASH_SIZE*2+1]; for(i=0; i