18ed2b524SDag-Erling Smørgrav /* 28ed2b524SDag-Erling Smørgrav * validator/val_secalgo.c - validator security algorithm functions. 38ed2b524SDag-Erling Smørgrav * 48ed2b524SDag-Erling Smørgrav * Copyright (c) 2012, NLnet Labs. All rights reserved. 58ed2b524SDag-Erling Smørgrav * 68ed2b524SDag-Erling Smørgrav * This software is open source. 78ed2b524SDag-Erling Smørgrav * 88ed2b524SDag-Erling Smørgrav * Redistribution and use in source and binary forms, with or without 98ed2b524SDag-Erling Smørgrav * modification, are permitted provided that the following conditions 108ed2b524SDag-Erling Smørgrav * are met: 118ed2b524SDag-Erling Smørgrav * 128ed2b524SDag-Erling Smørgrav * Redistributions of source code must retain the above copyright notice, 138ed2b524SDag-Erling Smørgrav * this list of conditions and the following disclaimer. 148ed2b524SDag-Erling Smørgrav * 158ed2b524SDag-Erling Smørgrav * Redistributions in binary form must reproduce the above copyright notice, 168ed2b524SDag-Erling Smørgrav * this list of conditions and the following disclaimer in the documentation 178ed2b524SDag-Erling Smørgrav * and/or other materials provided with the distribution. 188ed2b524SDag-Erling Smørgrav * 198ed2b524SDag-Erling Smørgrav * Neither the name of the NLNET LABS nor the names of its contributors may 208ed2b524SDag-Erling Smørgrav * be used to endorse or promote products derived from this software without 218ed2b524SDag-Erling Smørgrav * specific prior written permission. 228ed2b524SDag-Erling Smørgrav * 238ed2b524SDag-Erling Smørgrav * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 2417d15b25SDag-Erling Smørgrav * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2517d15b25SDag-Erling Smørgrav * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2617d15b25SDag-Erling Smørgrav * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2717d15b25SDag-Erling Smørgrav * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2817d15b25SDag-Erling Smørgrav * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 2917d15b25SDag-Erling Smørgrav * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 3017d15b25SDag-Erling Smørgrav * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 3117d15b25SDag-Erling Smørgrav * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 3217d15b25SDag-Erling Smørgrav * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 3317d15b25SDag-Erling Smørgrav * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 348ed2b524SDag-Erling Smørgrav */ 358ed2b524SDag-Erling Smørgrav 368ed2b524SDag-Erling Smørgrav /** 378ed2b524SDag-Erling Smørgrav * \file 388ed2b524SDag-Erling Smørgrav * 398ed2b524SDag-Erling Smørgrav * This file contains helper functions for the validator module. 408ed2b524SDag-Erling Smørgrav * These functions take raw data buffers, formatted for crypto verification, 418ed2b524SDag-Erling Smørgrav * and do the library calls (for the crypto library in use). 428ed2b524SDag-Erling Smørgrav */ 438ed2b524SDag-Erling Smørgrav #include "config.h" 446480faa8SDag-Erling Smørgrav /* packed_rrset on top to define enum types (forced by c99 standard) */ 458ed2b524SDag-Erling Smørgrav #include "util/data/packed_rrset.h" 466480faa8SDag-Erling Smørgrav #include "validator/val_secalgo.h" 4705ab2901SDag-Erling Smørgrav #include "validator/val_nsec3.h" 488ed2b524SDag-Erling Smørgrav #include "util/log.h" 4909a3aaf3SDag-Erling Smørgrav #include "sldns/rrdef.h" 5009a3aaf3SDag-Erling Smørgrav #include "sldns/keyraw.h" 5109a3aaf3SDag-Erling Smørgrav #include "sldns/sbuffer.h" 528ed2b524SDag-Erling Smørgrav 5305ab2901SDag-Erling Smørgrav #if !defined(HAVE_SSL) && !defined(HAVE_NSS) && !defined(HAVE_NETTLE) 548ed2b524SDag-Erling Smørgrav #error "Need crypto library to do digital signature cryptography" 558ed2b524SDag-Erling Smørgrav #endif 568ed2b524SDag-Erling Smørgrav 578ed2b524SDag-Erling Smørgrav /* OpenSSL implementation */ 588ed2b524SDag-Erling Smørgrav #ifdef HAVE_SSL 598ed2b524SDag-Erling Smørgrav #ifdef HAVE_OPENSSL_ERR_H 608ed2b524SDag-Erling Smørgrav #include <openssl/err.h> 618ed2b524SDag-Erling Smørgrav #endif 628ed2b524SDag-Erling Smørgrav 638ed2b524SDag-Erling Smørgrav #ifdef HAVE_OPENSSL_RAND_H 648ed2b524SDag-Erling Smørgrav #include <openssl/rand.h> 658ed2b524SDag-Erling Smørgrav #endif 668ed2b524SDag-Erling Smørgrav 678ed2b524SDag-Erling Smørgrav #ifdef HAVE_OPENSSL_CONF_H 688ed2b524SDag-Erling Smørgrav #include <openssl/conf.h> 698ed2b524SDag-Erling Smørgrav #endif 708ed2b524SDag-Erling Smørgrav 718ed2b524SDag-Erling Smørgrav #ifdef HAVE_OPENSSL_ENGINE_H 728ed2b524SDag-Erling Smørgrav #include <openssl/engine.h> 738ed2b524SDag-Erling Smørgrav #endif 748ed2b524SDag-Erling Smørgrav 7505ab2901SDag-Erling Smørgrav /* return size of digest if supported, or 0 otherwise */ 7605ab2901SDag-Erling Smørgrav size_t 7705ab2901SDag-Erling Smørgrav nsec3_hash_algo_size_supported(int id) 7805ab2901SDag-Erling Smørgrav { 7905ab2901SDag-Erling Smørgrav switch(id) { 8005ab2901SDag-Erling Smørgrav case NSEC3_HASH_SHA1: 8105ab2901SDag-Erling Smørgrav return SHA_DIGEST_LENGTH; 8205ab2901SDag-Erling Smørgrav default: 8305ab2901SDag-Erling Smørgrav return 0; 8405ab2901SDag-Erling Smørgrav } 8505ab2901SDag-Erling Smørgrav } 8605ab2901SDag-Erling Smørgrav 8705ab2901SDag-Erling Smørgrav /* perform nsec3 hash. return false on failure */ 8805ab2901SDag-Erling Smørgrav int 8905ab2901SDag-Erling Smørgrav secalgo_nsec3_hash(int algo, unsigned char* buf, size_t len, 9005ab2901SDag-Erling Smørgrav unsigned char* res) 9105ab2901SDag-Erling Smørgrav { 9205ab2901SDag-Erling Smørgrav switch(algo) { 9305ab2901SDag-Erling Smørgrav case NSEC3_HASH_SHA1: 9405ab2901SDag-Erling Smørgrav (void)SHA1(buf, len, res); 9505ab2901SDag-Erling Smørgrav return 1; 9605ab2901SDag-Erling Smørgrav default: 9705ab2901SDag-Erling Smørgrav return 0; 9805ab2901SDag-Erling Smørgrav } 9905ab2901SDag-Erling Smørgrav } 10005ab2901SDag-Erling Smørgrav 1018ed2b524SDag-Erling Smørgrav /** 1028ed2b524SDag-Erling Smørgrav * Return size of DS digest according to its hash algorithm. 1038ed2b524SDag-Erling Smørgrav * @param algo: DS digest algo. 1048ed2b524SDag-Erling Smørgrav * @return size in bytes of digest, or 0 if not supported. 1058ed2b524SDag-Erling Smørgrav */ 1068ed2b524SDag-Erling Smørgrav size_t 1078ed2b524SDag-Erling Smørgrav ds_digest_size_supported(int algo) 1088ed2b524SDag-Erling Smørgrav { 1098ed2b524SDag-Erling Smørgrav switch(algo) { 1108ed2b524SDag-Erling Smørgrav #ifdef HAVE_EVP_SHA1 1118ed2b524SDag-Erling Smørgrav case LDNS_SHA1: 1128ed2b524SDag-Erling Smørgrav return SHA_DIGEST_LENGTH; 1138ed2b524SDag-Erling Smørgrav #endif 1148ed2b524SDag-Erling Smørgrav #ifdef HAVE_EVP_SHA256 1158ed2b524SDag-Erling Smørgrav case LDNS_SHA256: 1168ed2b524SDag-Erling Smørgrav return SHA256_DIGEST_LENGTH; 1178ed2b524SDag-Erling Smørgrav #endif 1188ed2b524SDag-Erling Smørgrav #ifdef USE_GOST 1198ed2b524SDag-Erling Smørgrav case LDNS_HASH_GOST: 120*f61ef7f6SDag-Erling Smørgrav /* we support GOST if it can be loaded */ 121*f61ef7f6SDag-Erling Smørgrav (void)sldns_key_EVP_load_gost_id(); 1228ed2b524SDag-Erling Smørgrav if(EVP_get_digestbyname("md_gost94")) 1238ed2b524SDag-Erling Smørgrav return 32; 1248ed2b524SDag-Erling Smørgrav else return 0; 1258ed2b524SDag-Erling Smørgrav #endif 1268ed2b524SDag-Erling Smørgrav #ifdef USE_ECDSA 1278ed2b524SDag-Erling Smørgrav case LDNS_SHA384: 1288ed2b524SDag-Erling Smørgrav return SHA384_DIGEST_LENGTH; 1298ed2b524SDag-Erling Smørgrav #endif 1308ed2b524SDag-Erling Smørgrav default: break; 1318ed2b524SDag-Erling Smørgrav } 1328ed2b524SDag-Erling Smørgrav return 0; 1338ed2b524SDag-Erling Smørgrav } 1348ed2b524SDag-Erling Smørgrav 1358ed2b524SDag-Erling Smørgrav #ifdef USE_GOST 1368ed2b524SDag-Erling Smørgrav /** Perform GOST hash */ 1378ed2b524SDag-Erling Smørgrav static int 1388ed2b524SDag-Erling Smørgrav do_gost94(unsigned char* data, size_t len, unsigned char* dest) 1398ed2b524SDag-Erling Smørgrav { 1408ed2b524SDag-Erling Smørgrav const EVP_MD* md = EVP_get_digestbyname("md_gost94"); 1418ed2b524SDag-Erling Smørgrav if(!md) 1428ed2b524SDag-Erling Smørgrav return 0; 14317d15b25SDag-Erling Smørgrav return sldns_digest_evp(data, (unsigned int)len, dest, md); 1448ed2b524SDag-Erling Smørgrav } 1458ed2b524SDag-Erling Smørgrav #endif 1468ed2b524SDag-Erling Smørgrav 1478ed2b524SDag-Erling Smørgrav int 1488ed2b524SDag-Erling Smørgrav secalgo_ds_digest(int algo, unsigned char* buf, size_t len, 1498ed2b524SDag-Erling Smørgrav unsigned char* res) 1508ed2b524SDag-Erling Smørgrav { 1518ed2b524SDag-Erling Smørgrav switch(algo) { 1528ed2b524SDag-Erling Smørgrav #ifdef HAVE_EVP_SHA1 1538ed2b524SDag-Erling Smørgrav case LDNS_SHA1: 1548ed2b524SDag-Erling Smørgrav (void)SHA1(buf, len, res); 1558ed2b524SDag-Erling Smørgrav return 1; 1568ed2b524SDag-Erling Smørgrav #endif 1578ed2b524SDag-Erling Smørgrav #ifdef HAVE_EVP_SHA256 1588ed2b524SDag-Erling Smørgrav case LDNS_SHA256: 1598ed2b524SDag-Erling Smørgrav (void)SHA256(buf, len, res); 1608ed2b524SDag-Erling Smørgrav return 1; 1618ed2b524SDag-Erling Smørgrav #endif 1628ed2b524SDag-Erling Smørgrav #ifdef USE_GOST 1638ed2b524SDag-Erling Smørgrav case LDNS_HASH_GOST: 1648ed2b524SDag-Erling Smørgrav if(do_gost94(buf, len, res)) 1658ed2b524SDag-Erling Smørgrav return 1; 1668ed2b524SDag-Erling Smørgrav break; 1678ed2b524SDag-Erling Smørgrav #endif 1688ed2b524SDag-Erling Smørgrav #ifdef USE_ECDSA 1698ed2b524SDag-Erling Smørgrav case LDNS_SHA384: 1708ed2b524SDag-Erling Smørgrav (void)SHA384(buf, len, res); 1718ed2b524SDag-Erling Smørgrav return 1; 1728ed2b524SDag-Erling Smørgrav #endif 1738ed2b524SDag-Erling Smørgrav default: 1748ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "unknown DS digest algorithm %d", 1758ed2b524SDag-Erling Smørgrav algo); 1768ed2b524SDag-Erling Smørgrav break; 1778ed2b524SDag-Erling Smørgrav } 1788ed2b524SDag-Erling Smørgrav return 0; 1798ed2b524SDag-Erling Smørgrav } 1808ed2b524SDag-Erling Smørgrav 1818ed2b524SDag-Erling Smørgrav /** return true if DNSKEY algorithm id is supported */ 1828ed2b524SDag-Erling Smørgrav int 1838ed2b524SDag-Erling Smørgrav dnskey_algo_id_is_supported(int id) 1848ed2b524SDag-Erling Smørgrav { 1858ed2b524SDag-Erling Smørgrav switch(id) { 1868ed2b524SDag-Erling Smørgrav case LDNS_RSAMD5: 1878ed2b524SDag-Erling Smørgrav /* RFC 6725 deprecates RSAMD5 */ 1888ed2b524SDag-Erling Smørgrav return 0; 1898ed2b524SDag-Erling Smørgrav case LDNS_DSA: 1908ed2b524SDag-Erling Smørgrav case LDNS_DSA_NSEC3: 1918ed2b524SDag-Erling Smørgrav case LDNS_RSASHA1: 1928ed2b524SDag-Erling Smørgrav case LDNS_RSASHA1_NSEC3: 1938ed2b524SDag-Erling Smørgrav #if defined(HAVE_EVP_SHA256) && defined(USE_SHA2) 1948ed2b524SDag-Erling Smørgrav case LDNS_RSASHA256: 1958ed2b524SDag-Erling Smørgrav #endif 1968ed2b524SDag-Erling Smørgrav #if defined(HAVE_EVP_SHA512) && defined(USE_SHA2) 1978ed2b524SDag-Erling Smørgrav case LDNS_RSASHA512: 1988ed2b524SDag-Erling Smørgrav #endif 1998ed2b524SDag-Erling Smørgrav #ifdef USE_ECDSA 2008ed2b524SDag-Erling Smørgrav case LDNS_ECDSAP256SHA256: 2018ed2b524SDag-Erling Smørgrav case LDNS_ECDSAP384SHA384: 2028ed2b524SDag-Erling Smørgrav #endif 2038ed2b524SDag-Erling Smørgrav return 1; 2048ed2b524SDag-Erling Smørgrav #ifdef USE_GOST 2058ed2b524SDag-Erling Smørgrav case LDNS_ECC_GOST: 2068ed2b524SDag-Erling Smørgrav /* we support GOST if it can be loaded */ 20717d15b25SDag-Erling Smørgrav return sldns_key_EVP_load_gost_id(); 2088ed2b524SDag-Erling Smørgrav #endif 2098ed2b524SDag-Erling Smørgrav default: 2108ed2b524SDag-Erling Smørgrav return 0; 2118ed2b524SDag-Erling Smørgrav } 2128ed2b524SDag-Erling Smørgrav } 2138ed2b524SDag-Erling Smørgrav 2148ed2b524SDag-Erling Smørgrav /** 2158ed2b524SDag-Erling Smørgrav * Output a libcrypto openssl error to the logfile. 2168ed2b524SDag-Erling Smørgrav * @param str: string to add to it. 2178ed2b524SDag-Erling Smørgrav * @param e: the error to output, error number from ERR_get_error(). 2188ed2b524SDag-Erling Smørgrav */ 2198ed2b524SDag-Erling Smørgrav static void 2208ed2b524SDag-Erling Smørgrav log_crypto_error(const char* str, unsigned long e) 2218ed2b524SDag-Erling Smørgrav { 2228ed2b524SDag-Erling Smørgrav char buf[128]; 2238ed2b524SDag-Erling Smørgrav /* or use ERR_error_string if ERR_error_string_n is not avail TODO */ 2248ed2b524SDag-Erling Smørgrav ERR_error_string_n(e, buf, sizeof(buf)); 2258ed2b524SDag-Erling Smørgrav /* buf now contains */ 2268ed2b524SDag-Erling Smørgrav /* error:[error code]:[library name]:[function name]:[reason string] */ 2278ed2b524SDag-Erling Smørgrav log_err("%s crypto %s", str, buf); 2288ed2b524SDag-Erling Smørgrav } 2298ed2b524SDag-Erling Smørgrav 2308ed2b524SDag-Erling Smørgrav /** 2318ed2b524SDag-Erling Smørgrav * Setup DSA key digest in DER encoding ... 2328ed2b524SDag-Erling Smørgrav * @param sig: input is signature output alloced ptr (unless failure). 2338ed2b524SDag-Erling Smørgrav * caller must free alloced ptr if this routine returns true. 2348ed2b524SDag-Erling Smørgrav * @param len: input is initial siglen, output is output len. 2358ed2b524SDag-Erling Smørgrav * @return false on failure. 2368ed2b524SDag-Erling Smørgrav */ 2378ed2b524SDag-Erling Smørgrav static int 2388ed2b524SDag-Erling Smørgrav setup_dsa_sig(unsigned char** sig, unsigned int* len) 2398ed2b524SDag-Erling Smørgrav { 2408ed2b524SDag-Erling Smørgrav unsigned char* orig = *sig; 2418ed2b524SDag-Erling Smørgrav unsigned int origlen = *len; 2428ed2b524SDag-Erling Smørgrav int newlen; 2438ed2b524SDag-Erling Smørgrav BIGNUM *R, *S; 2448ed2b524SDag-Erling Smørgrav DSA_SIG *dsasig; 2458ed2b524SDag-Erling Smørgrav 2468ed2b524SDag-Erling Smørgrav /* extract the R and S field from the sig buffer */ 2478ed2b524SDag-Erling Smørgrav if(origlen < 1 + 2*SHA_DIGEST_LENGTH) 2488ed2b524SDag-Erling Smørgrav return 0; 2498ed2b524SDag-Erling Smørgrav R = BN_new(); 2508ed2b524SDag-Erling Smørgrav if(!R) return 0; 2518ed2b524SDag-Erling Smørgrav (void) BN_bin2bn(orig + 1, SHA_DIGEST_LENGTH, R); 2528ed2b524SDag-Erling Smørgrav S = BN_new(); 2538ed2b524SDag-Erling Smørgrav if(!S) return 0; 2548ed2b524SDag-Erling Smørgrav (void) BN_bin2bn(orig + 21, SHA_DIGEST_LENGTH, S); 2558ed2b524SDag-Erling Smørgrav dsasig = DSA_SIG_new(); 2568ed2b524SDag-Erling Smørgrav if(!dsasig) return 0; 2578ed2b524SDag-Erling Smørgrav 2588ed2b524SDag-Erling Smørgrav dsasig->r = R; 2598ed2b524SDag-Erling Smørgrav dsasig->s = S; 2608ed2b524SDag-Erling Smørgrav *sig = NULL; 2618ed2b524SDag-Erling Smørgrav newlen = i2d_DSA_SIG(dsasig, sig); 2628ed2b524SDag-Erling Smørgrav if(newlen < 0) { 2638ed2b524SDag-Erling Smørgrav DSA_SIG_free(dsasig); 2648ed2b524SDag-Erling Smørgrav free(*sig); 2658ed2b524SDag-Erling Smørgrav return 0; 2668ed2b524SDag-Erling Smørgrav } 2678ed2b524SDag-Erling Smørgrav *len = (unsigned int)newlen; 2688ed2b524SDag-Erling Smørgrav DSA_SIG_free(dsasig); 2698ed2b524SDag-Erling Smørgrav return 1; 2708ed2b524SDag-Erling Smørgrav } 2718ed2b524SDag-Erling Smørgrav 2728ed2b524SDag-Erling Smørgrav #ifdef USE_ECDSA 2738ed2b524SDag-Erling Smørgrav /** 2748ed2b524SDag-Erling Smørgrav * Setup the ECDSA signature in its encoding that the library wants. 2758ed2b524SDag-Erling Smørgrav * Converts from plain numbers to ASN formatted. 2768ed2b524SDag-Erling Smørgrav * @param sig: input is signature, output alloced ptr (unless failure). 2778ed2b524SDag-Erling Smørgrav * caller must free alloced ptr if this routine returns true. 2788ed2b524SDag-Erling Smørgrav * @param len: input is initial siglen, output is output len. 2798ed2b524SDag-Erling Smørgrav * @return false on failure. 2808ed2b524SDag-Erling Smørgrav */ 2818ed2b524SDag-Erling Smørgrav static int 2828ed2b524SDag-Erling Smørgrav setup_ecdsa_sig(unsigned char** sig, unsigned int* len) 2838ed2b524SDag-Erling Smørgrav { 2848ed2b524SDag-Erling Smørgrav ECDSA_SIG* ecdsa_sig; 2858ed2b524SDag-Erling Smørgrav int newlen; 2868ed2b524SDag-Erling Smørgrav int bnsize = (int)((*len)/2); 2878ed2b524SDag-Erling Smørgrav /* if too short or not even length, fails */ 2888ed2b524SDag-Erling Smørgrav if(*len < 16 || bnsize*2 != (int)*len) 2898ed2b524SDag-Erling Smørgrav return 0; 2908ed2b524SDag-Erling Smørgrav /* use the raw data to parse two evenly long BIGNUMs, "r | s". */ 2918ed2b524SDag-Erling Smørgrav ecdsa_sig = ECDSA_SIG_new(); 2928ed2b524SDag-Erling Smørgrav if(!ecdsa_sig) return 0; 2938ed2b524SDag-Erling Smørgrav ecdsa_sig->r = BN_bin2bn(*sig, bnsize, ecdsa_sig->r); 2948ed2b524SDag-Erling Smørgrav ecdsa_sig->s = BN_bin2bn(*sig+bnsize, bnsize, ecdsa_sig->s); 2958ed2b524SDag-Erling Smørgrav if(!ecdsa_sig->r || !ecdsa_sig->s) { 2968ed2b524SDag-Erling Smørgrav ECDSA_SIG_free(ecdsa_sig); 2978ed2b524SDag-Erling Smørgrav return 0; 2988ed2b524SDag-Erling Smørgrav } 2998ed2b524SDag-Erling Smørgrav 3008ed2b524SDag-Erling Smørgrav /* spool it into ASN format */ 3018ed2b524SDag-Erling Smørgrav *sig = NULL; 3028ed2b524SDag-Erling Smørgrav newlen = i2d_ECDSA_SIG(ecdsa_sig, sig); 3038ed2b524SDag-Erling Smørgrav if(newlen <= 0) { 3048ed2b524SDag-Erling Smørgrav ECDSA_SIG_free(ecdsa_sig); 3058ed2b524SDag-Erling Smørgrav free(*sig); 3068ed2b524SDag-Erling Smørgrav return 0; 3078ed2b524SDag-Erling Smørgrav } 3088ed2b524SDag-Erling Smørgrav *len = (unsigned int)newlen; 3098ed2b524SDag-Erling Smørgrav ECDSA_SIG_free(ecdsa_sig); 3108ed2b524SDag-Erling Smørgrav return 1; 3118ed2b524SDag-Erling Smørgrav } 3128ed2b524SDag-Erling Smørgrav #endif /* USE_ECDSA */ 3138ed2b524SDag-Erling Smørgrav 3148ed2b524SDag-Erling Smørgrav /** 3158ed2b524SDag-Erling Smørgrav * Setup key and digest for verification. Adjust sig if necessary. 3168ed2b524SDag-Erling Smørgrav * 3178ed2b524SDag-Erling Smørgrav * @param algo: key algorithm 3188ed2b524SDag-Erling Smørgrav * @param evp_key: EVP PKEY public key to create. 3198ed2b524SDag-Erling Smørgrav * @param digest_type: digest type to use 3208ed2b524SDag-Erling Smørgrav * @param key: key to setup for. 3218ed2b524SDag-Erling Smørgrav * @param keylen: length of key. 3228ed2b524SDag-Erling Smørgrav * @return false on failure. 3238ed2b524SDag-Erling Smørgrav */ 3248ed2b524SDag-Erling Smørgrav static int 3258ed2b524SDag-Erling Smørgrav setup_key_digest(int algo, EVP_PKEY** evp_key, const EVP_MD** digest_type, 3268ed2b524SDag-Erling Smørgrav unsigned char* key, size_t keylen) 3278ed2b524SDag-Erling Smørgrav { 3288ed2b524SDag-Erling Smørgrav DSA* dsa; 3298ed2b524SDag-Erling Smørgrav RSA* rsa; 3308ed2b524SDag-Erling Smørgrav 3318ed2b524SDag-Erling Smørgrav switch(algo) { 3328ed2b524SDag-Erling Smørgrav case LDNS_DSA: 3338ed2b524SDag-Erling Smørgrav case LDNS_DSA_NSEC3: 3348ed2b524SDag-Erling Smørgrav *evp_key = EVP_PKEY_new(); 3358ed2b524SDag-Erling Smørgrav if(!*evp_key) { 3368ed2b524SDag-Erling Smørgrav log_err("verify: malloc failure in crypto"); 3378ed2b524SDag-Erling Smørgrav return 0; 3388ed2b524SDag-Erling Smørgrav } 33917d15b25SDag-Erling Smørgrav dsa = sldns_key_buf2dsa_raw(key, keylen); 3408ed2b524SDag-Erling Smørgrav if(!dsa) { 3418ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: " 34217d15b25SDag-Erling Smørgrav "sldns_key_buf2dsa_raw failed"); 3438ed2b524SDag-Erling Smørgrav return 0; 3448ed2b524SDag-Erling Smørgrav } 3458ed2b524SDag-Erling Smørgrav if(EVP_PKEY_assign_DSA(*evp_key, dsa) == 0) { 3468ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: " 3478ed2b524SDag-Erling Smørgrav "EVP_PKEY_assign_DSA failed"); 3488ed2b524SDag-Erling Smørgrav return 0; 3498ed2b524SDag-Erling Smørgrav } 3508ed2b524SDag-Erling Smørgrav *digest_type = EVP_dss1(); 3518ed2b524SDag-Erling Smørgrav 3528ed2b524SDag-Erling Smørgrav break; 3538ed2b524SDag-Erling Smørgrav case LDNS_RSASHA1: 3548ed2b524SDag-Erling Smørgrav case LDNS_RSASHA1_NSEC3: 3558ed2b524SDag-Erling Smørgrav #if defined(HAVE_EVP_SHA256) && defined(USE_SHA2) 3568ed2b524SDag-Erling Smørgrav case LDNS_RSASHA256: 3578ed2b524SDag-Erling Smørgrav #endif 3588ed2b524SDag-Erling Smørgrav #if defined(HAVE_EVP_SHA512) && defined(USE_SHA2) 3598ed2b524SDag-Erling Smørgrav case LDNS_RSASHA512: 3608ed2b524SDag-Erling Smørgrav #endif 3618ed2b524SDag-Erling Smørgrav *evp_key = EVP_PKEY_new(); 3628ed2b524SDag-Erling Smørgrav if(!*evp_key) { 3638ed2b524SDag-Erling Smørgrav log_err("verify: malloc failure in crypto"); 3648ed2b524SDag-Erling Smørgrav return 0; 3658ed2b524SDag-Erling Smørgrav } 36617d15b25SDag-Erling Smørgrav rsa = sldns_key_buf2rsa_raw(key, keylen); 3678ed2b524SDag-Erling Smørgrav if(!rsa) { 3688ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: " 36917d15b25SDag-Erling Smørgrav "sldns_key_buf2rsa_raw SHA failed"); 3708ed2b524SDag-Erling Smørgrav return 0; 3718ed2b524SDag-Erling Smørgrav } 3728ed2b524SDag-Erling Smørgrav if(EVP_PKEY_assign_RSA(*evp_key, rsa) == 0) { 3738ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: " 3748ed2b524SDag-Erling Smørgrav "EVP_PKEY_assign_RSA SHA failed"); 3758ed2b524SDag-Erling Smørgrav return 0; 3768ed2b524SDag-Erling Smørgrav } 3778ed2b524SDag-Erling Smørgrav 3788ed2b524SDag-Erling Smørgrav /* select SHA version */ 3798ed2b524SDag-Erling Smørgrav #if defined(HAVE_EVP_SHA256) && defined(USE_SHA2) 3808ed2b524SDag-Erling Smørgrav if(algo == LDNS_RSASHA256) 3818ed2b524SDag-Erling Smørgrav *digest_type = EVP_sha256(); 3828ed2b524SDag-Erling Smørgrav else 3838ed2b524SDag-Erling Smørgrav #endif 3848ed2b524SDag-Erling Smørgrav #if defined(HAVE_EVP_SHA512) && defined(USE_SHA2) 3858ed2b524SDag-Erling Smørgrav if(algo == LDNS_RSASHA512) 3868ed2b524SDag-Erling Smørgrav *digest_type = EVP_sha512(); 3878ed2b524SDag-Erling Smørgrav else 3888ed2b524SDag-Erling Smørgrav #endif 3898ed2b524SDag-Erling Smørgrav *digest_type = EVP_sha1(); 3908ed2b524SDag-Erling Smørgrav 3918ed2b524SDag-Erling Smørgrav break; 3928ed2b524SDag-Erling Smørgrav case LDNS_RSAMD5: 3938ed2b524SDag-Erling Smørgrav *evp_key = EVP_PKEY_new(); 3948ed2b524SDag-Erling Smørgrav if(!*evp_key) { 3958ed2b524SDag-Erling Smørgrav log_err("verify: malloc failure in crypto"); 3968ed2b524SDag-Erling Smørgrav return 0; 3978ed2b524SDag-Erling Smørgrav } 39817d15b25SDag-Erling Smørgrav rsa = sldns_key_buf2rsa_raw(key, keylen); 3998ed2b524SDag-Erling Smørgrav if(!rsa) { 4008ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: " 40117d15b25SDag-Erling Smørgrav "sldns_key_buf2rsa_raw MD5 failed"); 4028ed2b524SDag-Erling Smørgrav return 0; 4038ed2b524SDag-Erling Smørgrav } 4048ed2b524SDag-Erling Smørgrav if(EVP_PKEY_assign_RSA(*evp_key, rsa) == 0) { 4058ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: " 4068ed2b524SDag-Erling Smørgrav "EVP_PKEY_assign_RSA MD5 failed"); 4078ed2b524SDag-Erling Smørgrav return 0; 4088ed2b524SDag-Erling Smørgrav } 4098ed2b524SDag-Erling Smørgrav *digest_type = EVP_md5(); 4108ed2b524SDag-Erling Smørgrav 4118ed2b524SDag-Erling Smørgrav break; 4128ed2b524SDag-Erling Smørgrav #ifdef USE_GOST 4138ed2b524SDag-Erling Smørgrav case LDNS_ECC_GOST: 41417d15b25SDag-Erling Smørgrav *evp_key = sldns_gost2pkey_raw(key, keylen); 4158ed2b524SDag-Erling Smørgrav if(!*evp_key) { 4168ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: " 41717d15b25SDag-Erling Smørgrav "sldns_gost2pkey_raw failed"); 4188ed2b524SDag-Erling Smørgrav return 0; 4198ed2b524SDag-Erling Smørgrav } 4208ed2b524SDag-Erling Smørgrav *digest_type = EVP_get_digestbyname("md_gost94"); 4218ed2b524SDag-Erling Smørgrav if(!*digest_type) { 4228ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: " 4238ed2b524SDag-Erling Smørgrav "EVP_getdigest md_gost94 failed"); 4248ed2b524SDag-Erling Smørgrav return 0; 4258ed2b524SDag-Erling Smørgrav } 4268ed2b524SDag-Erling Smørgrav break; 4278ed2b524SDag-Erling Smørgrav #endif 4288ed2b524SDag-Erling Smørgrav #ifdef USE_ECDSA 4298ed2b524SDag-Erling Smørgrav case LDNS_ECDSAP256SHA256: 43017d15b25SDag-Erling Smørgrav *evp_key = sldns_ecdsa2pkey_raw(key, keylen, 4318ed2b524SDag-Erling Smørgrav LDNS_ECDSAP256SHA256); 4328ed2b524SDag-Erling Smørgrav if(!*evp_key) { 4338ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: " 43417d15b25SDag-Erling Smørgrav "sldns_ecdsa2pkey_raw failed"); 4358ed2b524SDag-Erling Smørgrav return 0; 4368ed2b524SDag-Erling Smørgrav } 4378ed2b524SDag-Erling Smørgrav #ifdef USE_ECDSA_EVP_WORKAROUND 4388ed2b524SDag-Erling Smørgrav /* openssl before 1.0.0 fixes RSA with the SHA256 4398ed2b524SDag-Erling Smørgrav * hash in EVP. We create one for ecdsa_sha256 */ 4408ed2b524SDag-Erling Smørgrav { 4418ed2b524SDag-Erling Smørgrav static int md_ecdsa_256_done = 0; 4428ed2b524SDag-Erling Smørgrav static EVP_MD md; 4438ed2b524SDag-Erling Smørgrav if(!md_ecdsa_256_done) { 4448ed2b524SDag-Erling Smørgrav EVP_MD m = *EVP_sha256(); 4458ed2b524SDag-Erling Smørgrav md_ecdsa_256_done = 1; 4468ed2b524SDag-Erling Smørgrav m.required_pkey_type[0] = (*evp_key)->type; 4478ed2b524SDag-Erling Smørgrav m.verify = (void*)ECDSA_verify; 4488ed2b524SDag-Erling Smørgrav md = m; 4498ed2b524SDag-Erling Smørgrav } 4508ed2b524SDag-Erling Smørgrav *digest_type = &md; 4518ed2b524SDag-Erling Smørgrav } 4528ed2b524SDag-Erling Smørgrav #else 4538ed2b524SDag-Erling Smørgrav *digest_type = EVP_sha256(); 4548ed2b524SDag-Erling Smørgrav #endif 4558ed2b524SDag-Erling Smørgrav break; 4568ed2b524SDag-Erling Smørgrav case LDNS_ECDSAP384SHA384: 45717d15b25SDag-Erling Smørgrav *evp_key = sldns_ecdsa2pkey_raw(key, keylen, 4588ed2b524SDag-Erling Smørgrav LDNS_ECDSAP384SHA384); 4598ed2b524SDag-Erling Smørgrav if(!*evp_key) { 4608ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: " 46117d15b25SDag-Erling Smørgrav "sldns_ecdsa2pkey_raw failed"); 4628ed2b524SDag-Erling Smørgrav return 0; 4638ed2b524SDag-Erling Smørgrav } 4648ed2b524SDag-Erling Smørgrav #ifdef USE_ECDSA_EVP_WORKAROUND 4658ed2b524SDag-Erling Smørgrav /* openssl before 1.0.0 fixes RSA with the SHA384 4668ed2b524SDag-Erling Smørgrav * hash in EVP. We create one for ecdsa_sha384 */ 4678ed2b524SDag-Erling Smørgrav { 4688ed2b524SDag-Erling Smørgrav static int md_ecdsa_384_done = 0; 4698ed2b524SDag-Erling Smørgrav static EVP_MD md; 4708ed2b524SDag-Erling Smørgrav if(!md_ecdsa_384_done) { 4718ed2b524SDag-Erling Smørgrav EVP_MD m = *EVP_sha384(); 4728ed2b524SDag-Erling Smørgrav md_ecdsa_384_done = 1; 4738ed2b524SDag-Erling Smørgrav m.required_pkey_type[0] = (*evp_key)->type; 4748ed2b524SDag-Erling Smørgrav m.verify = (void*)ECDSA_verify; 4758ed2b524SDag-Erling Smørgrav md = m; 4768ed2b524SDag-Erling Smørgrav } 4778ed2b524SDag-Erling Smørgrav *digest_type = &md; 4788ed2b524SDag-Erling Smørgrav } 4798ed2b524SDag-Erling Smørgrav #else 4808ed2b524SDag-Erling Smørgrav *digest_type = EVP_sha384(); 4818ed2b524SDag-Erling Smørgrav #endif 4828ed2b524SDag-Erling Smørgrav break; 4838ed2b524SDag-Erling Smørgrav #endif /* USE_ECDSA */ 4848ed2b524SDag-Erling Smørgrav default: 4858ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: unknown algorithm %d", 4868ed2b524SDag-Erling Smørgrav algo); 4878ed2b524SDag-Erling Smørgrav return 0; 4888ed2b524SDag-Erling Smørgrav } 4898ed2b524SDag-Erling Smørgrav return 1; 4908ed2b524SDag-Erling Smørgrav } 4918ed2b524SDag-Erling Smørgrav 4928ed2b524SDag-Erling Smørgrav /** 4938ed2b524SDag-Erling Smørgrav * Check a canonical sig+rrset and signature against a dnskey 4948ed2b524SDag-Erling Smørgrav * @param buf: buffer with data to verify, the first rrsig part and the 4958ed2b524SDag-Erling Smørgrav * canonicalized rrset. 4968ed2b524SDag-Erling Smørgrav * @param algo: DNSKEY algorithm. 4978ed2b524SDag-Erling Smørgrav * @param sigblock: signature rdata field from RRSIG 4988ed2b524SDag-Erling Smørgrav * @param sigblock_len: length of sigblock data. 4998ed2b524SDag-Erling Smørgrav * @param key: public key data from DNSKEY RR. 5008ed2b524SDag-Erling Smørgrav * @param keylen: length of keydata. 5018ed2b524SDag-Erling Smørgrav * @param reason: bogus reason in more detail. 5028ed2b524SDag-Erling Smørgrav * @return secure if verification succeeded, bogus on crypto failure, 5038ed2b524SDag-Erling Smørgrav * unchecked on format errors and alloc failures. 5048ed2b524SDag-Erling Smørgrav */ 5058ed2b524SDag-Erling Smørgrav enum sec_status 50617d15b25SDag-Erling Smørgrav verify_canonrrset(sldns_buffer* buf, int algo, unsigned char* sigblock, 5078ed2b524SDag-Erling Smørgrav unsigned int sigblock_len, unsigned char* key, unsigned int keylen, 5088ed2b524SDag-Erling Smørgrav char** reason) 5098ed2b524SDag-Erling Smørgrav { 5108ed2b524SDag-Erling Smørgrav const EVP_MD *digest_type; 5118ed2b524SDag-Erling Smørgrav EVP_MD_CTX ctx; 5128ed2b524SDag-Erling Smørgrav int res, dofree = 0; 5138ed2b524SDag-Erling Smørgrav EVP_PKEY *evp_key = NULL; 5148ed2b524SDag-Erling Smørgrav 5158ed2b524SDag-Erling Smørgrav if(!setup_key_digest(algo, &evp_key, &digest_type, key, keylen)) { 5168ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: failed to setup key"); 5178ed2b524SDag-Erling Smørgrav *reason = "use of key for crypto failed"; 5188ed2b524SDag-Erling Smørgrav EVP_PKEY_free(evp_key); 5198ed2b524SDag-Erling Smørgrav return sec_status_bogus; 5208ed2b524SDag-Erling Smørgrav } 5218ed2b524SDag-Erling Smørgrav /* if it is a DSA signature in bind format, convert to DER format */ 5228ed2b524SDag-Erling Smørgrav if((algo == LDNS_DSA || algo == LDNS_DSA_NSEC3) && 5238ed2b524SDag-Erling Smørgrav sigblock_len == 1+2*SHA_DIGEST_LENGTH) { 5248ed2b524SDag-Erling Smørgrav if(!setup_dsa_sig(&sigblock, &sigblock_len)) { 5258ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: failed to setup DSA sig"); 5268ed2b524SDag-Erling Smørgrav *reason = "use of key for DSA crypto failed"; 5278ed2b524SDag-Erling Smørgrav EVP_PKEY_free(evp_key); 5288ed2b524SDag-Erling Smørgrav return sec_status_bogus; 5298ed2b524SDag-Erling Smørgrav } 5308ed2b524SDag-Erling Smørgrav dofree = 1; 5318ed2b524SDag-Erling Smørgrav } 5328ed2b524SDag-Erling Smørgrav #ifdef USE_ECDSA 5338ed2b524SDag-Erling Smørgrav else if(algo == LDNS_ECDSAP256SHA256 || algo == LDNS_ECDSAP384SHA384) { 5348ed2b524SDag-Erling Smørgrav /* EVP uses ASN prefix on sig, which is not in the wire data */ 5358ed2b524SDag-Erling Smørgrav if(!setup_ecdsa_sig(&sigblock, &sigblock_len)) { 5368ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: failed to setup ECDSA sig"); 5378ed2b524SDag-Erling Smørgrav *reason = "use of signature for ECDSA crypto failed"; 5388ed2b524SDag-Erling Smørgrav EVP_PKEY_free(evp_key); 5398ed2b524SDag-Erling Smørgrav return sec_status_bogus; 5408ed2b524SDag-Erling Smørgrav } 5418ed2b524SDag-Erling Smørgrav dofree = 1; 5428ed2b524SDag-Erling Smørgrav } 5438ed2b524SDag-Erling Smørgrav #endif /* USE_ECDSA */ 5448ed2b524SDag-Erling Smørgrav 5458ed2b524SDag-Erling Smørgrav /* do the signature cryptography work */ 5468ed2b524SDag-Erling Smørgrav EVP_MD_CTX_init(&ctx); 5478ed2b524SDag-Erling Smørgrav if(EVP_VerifyInit(&ctx, digest_type) == 0) { 5488ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: EVP_VerifyInit failed"); 5498ed2b524SDag-Erling Smørgrav EVP_PKEY_free(evp_key); 5508ed2b524SDag-Erling Smørgrav if(dofree) free(sigblock); 5518ed2b524SDag-Erling Smørgrav return sec_status_unchecked; 5528ed2b524SDag-Erling Smørgrav } 55317d15b25SDag-Erling Smørgrav if(EVP_VerifyUpdate(&ctx, (unsigned char*)sldns_buffer_begin(buf), 55417d15b25SDag-Erling Smørgrav (unsigned int)sldns_buffer_limit(buf)) == 0) { 5558ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: EVP_VerifyUpdate failed"); 5568ed2b524SDag-Erling Smørgrav EVP_PKEY_free(evp_key); 5578ed2b524SDag-Erling Smørgrav if(dofree) free(sigblock); 5588ed2b524SDag-Erling Smørgrav return sec_status_unchecked; 5598ed2b524SDag-Erling Smørgrav } 5608ed2b524SDag-Erling Smørgrav 5618ed2b524SDag-Erling Smørgrav res = EVP_VerifyFinal(&ctx, sigblock, sigblock_len, evp_key); 5628ed2b524SDag-Erling Smørgrav if(EVP_MD_CTX_cleanup(&ctx) == 0) { 5638ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: EVP_MD_CTX_cleanup failed"); 5648ed2b524SDag-Erling Smørgrav EVP_PKEY_free(evp_key); 5658ed2b524SDag-Erling Smørgrav if(dofree) free(sigblock); 5668ed2b524SDag-Erling Smørgrav return sec_status_unchecked; 5678ed2b524SDag-Erling Smørgrav } 5688ed2b524SDag-Erling Smørgrav EVP_PKEY_free(evp_key); 5698ed2b524SDag-Erling Smørgrav 5708ed2b524SDag-Erling Smørgrav if(dofree) 5718ed2b524SDag-Erling Smørgrav free(sigblock); 5728ed2b524SDag-Erling Smørgrav 5738ed2b524SDag-Erling Smørgrav if(res == 1) { 5748ed2b524SDag-Erling Smørgrav return sec_status_secure; 5758ed2b524SDag-Erling Smørgrav } else if(res == 0) { 5768ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: signature mismatch"); 5778ed2b524SDag-Erling Smørgrav *reason = "signature crypto failed"; 5788ed2b524SDag-Erling Smørgrav return sec_status_bogus; 5798ed2b524SDag-Erling Smørgrav } 5808ed2b524SDag-Erling Smørgrav 5818ed2b524SDag-Erling Smørgrav log_crypto_error("verify:", ERR_get_error()); 5828ed2b524SDag-Erling Smørgrav return sec_status_unchecked; 5838ed2b524SDag-Erling Smørgrav } 5848ed2b524SDag-Erling Smørgrav 5858ed2b524SDag-Erling Smørgrav /**************************************************/ 5868ed2b524SDag-Erling Smørgrav #elif defined(HAVE_NSS) 5878ed2b524SDag-Erling Smørgrav /* libnss implementation */ 5888ed2b524SDag-Erling Smørgrav /* nss3 */ 5898ed2b524SDag-Erling Smørgrav #include "sechash.h" 5908ed2b524SDag-Erling Smørgrav #include "pk11pub.h" 5918ed2b524SDag-Erling Smørgrav #include "keyhi.h" 5928ed2b524SDag-Erling Smørgrav #include "secerr.h" 5938ed2b524SDag-Erling Smørgrav #include "cryptohi.h" 5948ed2b524SDag-Erling Smørgrav /* nspr4 */ 5958ed2b524SDag-Erling Smørgrav #include "prerror.h" 5968ed2b524SDag-Erling Smørgrav 59705ab2901SDag-Erling Smørgrav /* return size of digest if supported, or 0 otherwise */ 59805ab2901SDag-Erling Smørgrav size_t 59905ab2901SDag-Erling Smørgrav nsec3_hash_algo_size_supported(int id) 60005ab2901SDag-Erling Smørgrav { 60105ab2901SDag-Erling Smørgrav switch(id) { 60205ab2901SDag-Erling Smørgrav case NSEC3_HASH_SHA1: 60305ab2901SDag-Erling Smørgrav return SHA1_LENGTH; 60405ab2901SDag-Erling Smørgrav default: 60505ab2901SDag-Erling Smørgrav return 0; 60605ab2901SDag-Erling Smørgrav } 60705ab2901SDag-Erling Smørgrav } 60805ab2901SDag-Erling Smørgrav 60905ab2901SDag-Erling Smørgrav /* perform nsec3 hash. return false on failure */ 61005ab2901SDag-Erling Smørgrav int 61105ab2901SDag-Erling Smørgrav secalgo_nsec3_hash(int algo, unsigned char* buf, size_t len, 61205ab2901SDag-Erling Smørgrav unsigned char* res) 61305ab2901SDag-Erling Smørgrav { 61405ab2901SDag-Erling Smørgrav switch(algo) { 61505ab2901SDag-Erling Smørgrav case NSEC3_HASH_SHA1: 61605ab2901SDag-Erling Smørgrav (void)HASH_HashBuf(HASH_AlgSHA1, res, buf, (unsigned long)len); 61705ab2901SDag-Erling Smørgrav return 1; 61805ab2901SDag-Erling Smørgrav default: 61905ab2901SDag-Erling Smørgrav return 0; 62005ab2901SDag-Erling Smørgrav } 62105ab2901SDag-Erling Smørgrav } 62205ab2901SDag-Erling Smørgrav 6238ed2b524SDag-Erling Smørgrav size_t 6248ed2b524SDag-Erling Smørgrav ds_digest_size_supported(int algo) 6258ed2b524SDag-Erling Smørgrav { 6268ed2b524SDag-Erling Smørgrav /* uses libNSS */ 6278ed2b524SDag-Erling Smørgrav switch(algo) { 6288ed2b524SDag-Erling Smørgrav case LDNS_SHA1: 6298ed2b524SDag-Erling Smørgrav return SHA1_LENGTH; 6308ed2b524SDag-Erling Smørgrav #ifdef USE_SHA2 6318ed2b524SDag-Erling Smørgrav case LDNS_SHA256: 6328ed2b524SDag-Erling Smørgrav return SHA256_LENGTH; 6338ed2b524SDag-Erling Smørgrav #endif 6348ed2b524SDag-Erling Smørgrav #ifdef USE_ECDSA 6358ed2b524SDag-Erling Smørgrav case LDNS_SHA384: 6368ed2b524SDag-Erling Smørgrav return SHA384_LENGTH; 6378ed2b524SDag-Erling Smørgrav #endif 6388ed2b524SDag-Erling Smørgrav /* GOST not supported in NSS */ 6398ed2b524SDag-Erling Smørgrav case LDNS_HASH_GOST: 6408ed2b524SDag-Erling Smørgrav default: break; 6418ed2b524SDag-Erling Smørgrav } 6428ed2b524SDag-Erling Smørgrav return 0; 6438ed2b524SDag-Erling Smørgrav } 6448ed2b524SDag-Erling Smørgrav 6458ed2b524SDag-Erling Smørgrav int 6468ed2b524SDag-Erling Smørgrav secalgo_ds_digest(int algo, unsigned char* buf, size_t len, 6478ed2b524SDag-Erling Smørgrav unsigned char* res) 6488ed2b524SDag-Erling Smørgrav { 6498ed2b524SDag-Erling Smørgrav /* uses libNSS */ 6508ed2b524SDag-Erling Smørgrav switch(algo) { 6518ed2b524SDag-Erling Smørgrav case LDNS_SHA1: 6528ed2b524SDag-Erling Smørgrav return HASH_HashBuf(HASH_AlgSHA1, res, buf, len) 6538ed2b524SDag-Erling Smørgrav == SECSuccess; 6548ed2b524SDag-Erling Smørgrav #if defined(USE_SHA2) 6558ed2b524SDag-Erling Smørgrav case LDNS_SHA256: 6568ed2b524SDag-Erling Smørgrav return HASH_HashBuf(HASH_AlgSHA256, res, buf, len) 6578ed2b524SDag-Erling Smørgrav == SECSuccess; 6588ed2b524SDag-Erling Smørgrav #endif 6598ed2b524SDag-Erling Smørgrav #ifdef USE_ECDSA 6608ed2b524SDag-Erling Smørgrav case LDNS_SHA384: 6618ed2b524SDag-Erling Smørgrav return HASH_HashBuf(HASH_AlgSHA384, res, buf, len) 6628ed2b524SDag-Erling Smørgrav == SECSuccess; 6638ed2b524SDag-Erling Smørgrav #endif 6648ed2b524SDag-Erling Smørgrav case LDNS_HASH_GOST: 6658ed2b524SDag-Erling Smørgrav default: 6668ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "unknown DS digest algorithm %d", 6678ed2b524SDag-Erling Smørgrav algo); 6688ed2b524SDag-Erling Smørgrav break; 6698ed2b524SDag-Erling Smørgrav } 6708ed2b524SDag-Erling Smørgrav return 0; 6718ed2b524SDag-Erling Smørgrav } 6728ed2b524SDag-Erling Smørgrav 6738ed2b524SDag-Erling Smørgrav int 6748ed2b524SDag-Erling Smørgrav dnskey_algo_id_is_supported(int id) 6758ed2b524SDag-Erling Smørgrav { 6768ed2b524SDag-Erling Smørgrav /* uses libNSS */ 6778ed2b524SDag-Erling Smørgrav switch(id) { 6788ed2b524SDag-Erling Smørgrav case LDNS_RSAMD5: 6798ed2b524SDag-Erling Smørgrav /* RFC 6725 deprecates RSAMD5 */ 6808ed2b524SDag-Erling Smørgrav return 0; 6818ed2b524SDag-Erling Smørgrav case LDNS_DSA: 6828ed2b524SDag-Erling Smørgrav case LDNS_DSA_NSEC3: 6838ed2b524SDag-Erling Smørgrav case LDNS_RSASHA1: 6848ed2b524SDag-Erling Smørgrav case LDNS_RSASHA1_NSEC3: 6858ed2b524SDag-Erling Smørgrav #ifdef USE_SHA2 6868ed2b524SDag-Erling Smørgrav case LDNS_RSASHA256: 6878ed2b524SDag-Erling Smørgrav #endif 6888ed2b524SDag-Erling Smørgrav #ifdef USE_SHA2 6898ed2b524SDag-Erling Smørgrav case LDNS_RSASHA512: 6908ed2b524SDag-Erling Smørgrav #endif 6918ed2b524SDag-Erling Smørgrav return 1; 6928ed2b524SDag-Erling Smørgrav #ifdef USE_ECDSA 6938ed2b524SDag-Erling Smørgrav case LDNS_ECDSAP256SHA256: 6948ed2b524SDag-Erling Smørgrav case LDNS_ECDSAP384SHA384: 6958ed2b524SDag-Erling Smørgrav return PK11_TokenExists(CKM_ECDSA); 6968ed2b524SDag-Erling Smørgrav #endif 6978ed2b524SDag-Erling Smørgrav case LDNS_ECC_GOST: 6988ed2b524SDag-Erling Smørgrav default: 6998ed2b524SDag-Erling Smørgrav return 0; 7008ed2b524SDag-Erling Smørgrav } 7018ed2b524SDag-Erling Smørgrav } 7028ed2b524SDag-Erling Smørgrav 7038ed2b524SDag-Erling Smørgrav /* return a new public key for NSS */ 7048ed2b524SDag-Erling Smørgrav static SECKEYPublicKey* nss_key_create(KeyType ktype) 7058ed2b524SDag-Erling Smørgrav { 7068ed2b524SDag-Erling Smørgrav SECKEYPublicKey* key; 7078ed2b524SDag-Erling Smørgrav PLArenaPool* arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); 7088ed2b524SDag-Erling Smørgrav if(!arena) { 7098ed2b524SDag-Erling Smørgrav log_err("out of memory, PORT_NewArena failed"); 7108ed2b524SDag-Erling Smørgrav return NULL; 7118ed2b524SDag-Erling Smørgrav } 7128ed2b524SDag-Erling Smørgrav key = PORT_ArenaZNew(arena, SECKEYPublicKey); 7138ed2b524SDag-Erling Smørgrav if(!key) { 7148ed2b524SDag-Erling Smørgrav log_err("out of memory, PORT_ArenaZNew failed"); 7158ed2b524SDag-Erling Smørgrav PORT_FreeArena(arena, PR_FALSE); 7168ed2b524SDag-Erling Smørgrav return NULL; 7178ed2b524SDag-Erling Smørgrav } 7188ed2b524SDag-Erling Smørgrav key->arena = arena; 7198ed2b524SDag-Erling Smørgrav key->keyType = ktype; 7208ed2b524SDag-Erling Smørgrav key->pkcs11Slot = NULL; 7218ed2b524SDag-Erling Smørgrav key->pkcs11ID = CK_INVALID_HANDLE; 7228ed2b524SDag-Erling Smørgrav return key; 7238ed2b524SDag-Erling Smørgrav } 7248ed2b524SDag-Erling Smørgrav 7258ed2b524SDag-Erling Smørgrav static SECKEYPublicKey* nss_buf2ecdsa(unsigned char* key, size_t len, int algo) 7268ed2b524SDag-Erling Smørgrav { 7278ed2b524SDag-Erling Smørgrav SECKEYPublicKey* pk; 7288ed2b524SDag-Erling Smørgrav SECItem pub = {siBuffer, NULL, 0}; 7298ed2b524SDag-Erling Smørgrav SECItem params = {siBuffer, NULL, 0}; 73017d15b25SDag-Erling Smørgrav static unsigned char param256[] = { 7318ed2b524SDag-Erling Smørgrav /* OBJECTIDENTIFIER 1.2.840.10045.3.1.7 (P-256) 7328ed2b524SDag-Erling Smørgrav * {iso(1) member-body(2) us(840) ansi-x962(10045) curves(3) prime(1) prime256v1(7)} */ 7338ed2b524SDag-Erling Smørgrav 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07 7348ed2b524SDag-Erling Smørgrav }; 73517d15b25SDag-Erling Smørgrav static unsigned char param384[] = { 7368ed2b524SDag-Erling Smørgrav /* OBJECTIDENTIFIER 1.3.132.0.34 (P-384) 7378ed2b524SDag-Erling Smørgrav * {iso(1) identified-organization(3) certicom(132) curve(0) ansip384r1(34)} */ 7388ed2b524SDag-Erling Smørgrav 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x22 7398ed2b524SDag-Erling Smørgrav }; 7408ed2b524SDag-Erling Smørgrav unsigned char buf[256+2]; /* sufficient for 2*384/8+1 */ 7418ed2b524SDag-Erling Smørgrav 7428ed2b524SDag-Erling Smørgrav /* check length, which uncompressed must be 2 bignums */ 7438ed2b524SDag-Erling Smørgrav if(algo == LDNS_ECDSAP256SHA256) { 7448ed2b524SDag-Erling Smørgrav if(len != 2*256/8) return NULL; 7458ed2b524SDag-Erling Smørgrav /* ECCurve_X9_62_PRIME_256V1 */ 7468ed2b524SDag-Erling Smørgrav } else if(algo == LDNS_ECDSAP384SHA384) { 7478ed2b524SDag-Erling Smørgrav if(len != 2*384/8) return NULL; 7488ed2b524SDag-Erling Smørgrav /* ECCurve_X9_62_PRIME_384R1 */ 7498ed2b524SDag-Erling Smørgrav } else return NULL; 7508ed2b524SDag-Erling Smørgrav 7518ed2b524SDag-Erling Smørgrav buf[0] = 0x04; /* POINT_FORM_UNCOMPRESSED */ 7528ed2b524SDag-Erling Smørgrav memmove(buf+1, key, len); 7538ed2b524SDag-Erling Smørgrav pub.data = buf; 7548ed2b524SDag-Erling Smørgrav pub.len = len+1; 7558ed2b524SDag-Erling Smørgrav if(algo == LDNS_ECDSAP256SHA256) { 7568ed2b524SDag-Erling Smørgrav params.data = param256; 7578ed2b524SDag-Erling Smørgrav params.len = sizeof(param256); 7588ed2b524SDag-Erling Smørgrav } else { 7598ed2b524SDag-Erling Smørgrav params.data = param384; 7608ed2b524SDag-Erling Smørgrav params.len = sizeof(param384); 7618ed2b524SDag-Erling Smørgrav } 7628ed2b524SDag-Erling Smørgrav 7638ed2b524SDag-Erling Smørgrav pk = nss_key_create(ecKey); 7648ed2b524SDag-Erling Smørgrav if(!pk) 7658ed2b524SDag-Erling Smørgrav return NULL; 7668ed2b524SDag-Erling Smørgrav pk->u.ec.size = (len/2)*8; 7678ed2b524SDag-Erling Smørgrav if(SECITEM_CopyItem(pk->arena, &pk->u.ec.publicValue, &pub)) { 7688ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pk); 7698ed2b524SDag-Erling Smørgrav return NULL; 7708ed2b524SDag-Erling Smørgrav } 7718ed2b524SDag-Erling Smørgrav if(SECITEM_CopyItem(pk->arena, &pk->u.ec.DEREncodedParams, ¶ms)) { 7728ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pk); 7738ed2b524SDag-Erling Smørgrav return NULL; 7748ed2b524SDag-Erling Smørgrav } 7758ed2b524SDag-Erling Smørgrav 7768ed2b524SDag-Erling Smørgrav return pk; 7778ed2b524SDag-Erling Smørgrav } 7788ed2b524SDag-Erling Smørgrav 7798ed2b524SDag-Erling Smørgrav static SECKEYPublicKey* nss_buf2dsa(unsigned char* key, size_t len) 7808ed2b524SDag-Erling Smørgrav { 7818ed2b524SDag-Erling Smørgrav SECKEYPublicKey* pk; 7828ed2b524SDag-Erling Smørgrav uint8_t T; 7838ed2b524SDag-Erling Smørgrav uint16_t length; 7848ed2b524SDag-Erling Smørgrav uint16_t offset; 7858ed2b524SDag-Erling Smørgrav SECItem Q = {siBuffer, NULL, 0}; 7868ed2b524SDag-Erling Smørgrav SECItem P = {siBuffer, NULL, 0}; 7878ed2b524SDag-Erling Smørgrav SECItem G = {siBuffer, NULL, 0}; 7888ed2b524SDag-Erling Smørgrav SECItem Y = {siBuffer, NULL, 0}; 7898ed2b524SDag-Erling Smørgrav 7908ed2b524SDag-Erling Smørgrav if(len == 0) 7918ed2b524SDag-Erling Smørgrav return NULL; 7928ed2b524SDag-Erling Smørgrav T = (uint8_t)key[0]; 7938ed2b524SDag-Erling Smørgrav length = (64 + T * 8); 7948ed2b524SDag-Erling Smørgrav offset = 1; 7958ed2b524SDag-Erling Smørgrav 7968ed2b524SDag-Erling Smørgrav if (T > 8) { 7978ed2b524SDag-Erling Smørgrav return NULL; 7988ed2b524SDag-Erling Smørgrav } 7998ed2b524SDag-Erling Smørgrav if(len < (size_t)1 + SHA1_LENGTH + 3*length) 8008ed2b524SDag-Erling Smørgrav return NULL; 8018ed2b524SDag-Erling Smørgrav 8028ed2b524SDag-Erling Smørgrav Q.data = key+offset; 8038ed2b524SDag-Erling Smørgrav Q.len = SHA1_LENGTH; 8048ed2b524SDag-Erling Smørgrav offset += SHA1_LENGTH; 8058ed2b524SDag-Erling Smørgrav 8068ed2b524SDag-Erling Smørgrav P.data = key+offset; 8078ed2b524SDag-Erling Smørgrav P.len = length; 8088ed2b524SDag-Erling Smørgrav offset += length; 8098ed2b524SDag-Erling Smørgrav 8108ed2b524SDag-Erling Smørgrav G.data = key+offset; 8118ed2b524SDag-Erling Smørgrav G.len = length; 8128ed2b524SDag-Erling Smørgrav offset += length; 8138ed2b524SDag-Erling Smørgrav 8148ed2b524SDag-Erling Smørgrav Y.data = key+offset; 8158ed2b524SDag-Erling Smørgrav Y.len = length; 8168ed2b524SDag-Erling Smørgrav offset += length; 8178ed2b524SDag-Erling Smørgrav 8188ed2b524SDag-Erling Smørgrav pk = nss_key_create(dsaKey); 8198ed2b524SDag-Erling Smørgrav if(!pk) 8208ed2b524SDag-Erling Smørgrav return NULL; 8218ed2b524SDag-Erling Smørgrav if(SECITEM_CopyItem(pk->arena, &pk->u.dsa.params.prime, &P)) { 8228ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pk); 8238ed2b524SDag-Erling Smørgrav return NULL; 8248ed2b524SDag-Erling Smørgrav } 8258ed2b524SDag-Erling Smørgrav if(SECITEM_CopyItem(pk->arena, &pk->u.dsa.params.subPrime, &Q)) { 8268ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pk); 8278ed2b524SDag-Erling Smørgrav return NULL; 8288ed2b524SDag-Erling Smørgrav } 8298ed2b524SDag-Erling Smørgrav if(SECITEM_CopyItem(pk->arena, &pk->u.dsa.params.base, &G)) { 8308ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pk); 8318ed2b524SDag-Erling Smørgrav return NULL; 8328ed2b524SDag-Erling Smørgrav } 8338ed2b524SDag-Erling Smørgrav if(SECITEM_CopyItem(pk->arena, &pk->u.dsa.publicValue, &Y)) { 8348ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pk); 8358ed2b524SDag-Erling Smørgrav return NULL; 8368ed2b524SDag-Erling Smørgrav } 8378ed2b524SDag-Erling Smørgrav return pk; 8388ed2b524SDag-Erling Smørgrav } 8398ed2b524SDag-Erling Smørgrav 8408ed2b524SDag-Erling Smørgrav static SECKEYPublicKey* nss_buf2rsa(unsigned char* key, size_t len) 8418ed2b524SDag-Erling Smørgrav { 8428ed2b524SDag-Erling Smørgrav SECKEYPublicKey* pk; 8438ed2b524SDag-Erling Smørgrav uint16_t exp; 8448ed2b524SDag-Erling Smørgrav uint16_t offset; 8458ed2b524SDag-Erling Smørgrav uint16_t int16; 8468ed2b524SDag-Erling Smørgrav SECItem modulus = {siBuffer, NULL, 0}; 8478ed2b524SDag-Erling Smørgrav SECItem exponent = {siBuffer, NULL, 0}; 8488ed2b524SDag-Erling Smørgrav if(len == 0) 8498ed2b524SDag-Erling Smørgrav return NULL; 8508ed2b524SDag-Erling Smørgrav if(key[0] == 0) { 8518ed2b524SDag-Erling Smørgrav if(len < 3) 8528ed2b524SDag-Erling Smørgrav return NULL; 8538ed2b524SDag-Erling Smørgrav /* the exponent is too large so it's places further */ 8548ed2b524SDag-Erling Smørgrav memmove(&int16, key+1, 2); 8558ed2b524SDag-Erling Smørgrav exp = ntohs(int16); 8568ed2b524SDag-Erling Smørgrav offset = 3; 8578ed2b524SDag-Erling Smørgrav } else { 8588ed2b524SDag-Erling Smørgrav exp = key[0]; 8598ed2b524SDag-Erling Smørgrav offset = 1; 8608ed2b524SDag-Erling Smørgrav } 8618ed2b524SDag-Erling Smørgrav 8628ed2b524SDag-Erling Smørgrav /* key length at least one */ 8638ed2b524SDag-Erling Smørgrav if(len < (size_t)offset + exp + 1) 8648ed2b524SDag-Erling Smørgrav return NULL; 8658ed2b524SDag-Erling Smørgrav 8668ed2b524SDag-Erling Smørgrav exponent.data = key+offset; 8678ed2b524SDag-Erling Smørgrav exponent.len = exp; 8688ed2b524SDag-Erling Smørgrav offset += exp; 8698ed2b524SDag-Erling Smørgrav modulus.data = key+offset; 8708ed2b524SDag-Erling Smørgrav modulus.len = (len - offset); 8718ed2b524SDag-Erling Smørgrav 8728ed2b524SDag-Erling Smørgrav pk = nss_key_create(rsaKey); 8738ed2b524SDag-Erling Smørgrav if(!pk) 8748ed2b524SDag-Erling Smørgrav return NULL; 8758ed2b524SDag-Erling Smørgrav if(SECITEM_CopyItem(pk->arena, &pk->u.rsa.modulus, &modulus)) { 8768ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pk); 8778ed2b524SDag-Erling Smørgrav return NULL; 8788ed2b524SDag-Erling Smørgrav } 8798ed2b524SDag-Erling Smørgrav if(SECITEM_CopyItem(pk->arena, &pk->u.rsa.publicExponent, &exponent)) { 8808ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pk); 8818ed2b524SDag-Erling Smørgrav return NULL; 8828ed2b524SDag-Erling Smørgrav } 8838ed2b524SDag-Erling Smørgrav return pk; 8848ed2b524SDag-Erling Smørgrav } 8858ed2b524SDag-Erling Smørgrav 8868ed2b524SDag-Erling Smørgrav /** 8878ed2b524SDag-Erling Smørgrav * Setup key and digest for verification. Adjust sig if necessary. 8888ed2b524SDag-Erling Smørgrav * 8898ed2b524SDag-Erling Smørgrav * @param algo: key algorithm 8908ed2b524SDag-Erling Smørgrav * @param evp_key: EVP PKEY public key to create. 8918ed2b524SDag-Erling Smørgrav * @param digest_type: digest type to use 8928ed2b524SDag-Erling Smørgrav * @param key: key to setup for. 8938ed2b524SDag-Erling Smørgrav * @param keylen: length of key. 8948ed2b524SDag-Erling Smørgrav * @param prefix: if returned, the ASN prefix for the hashblob. 8958ed2b524SDag-Erling Smørgrav * @param prefixlen: length of the prefix. 8968ed2b524SDag-Erling Smørgrav * @return false on failure. 8978ed2b524SDag-Erling Smørgrav */ 8988ed2b524SDag-Erling Smørgrav static int 8998ed2b524SDag-Erling Smørgrav nss_setup_key_digest(int algo, SECKEYPublicKey** pubkey, HASH_HashType* htype, 9008ed2b524SDag-Erling Smørgrav unsigned char* key, size_t keylen, unsigned char** prefix, 9018ed2b524SDag-Erling Smørgrav size_t* prefixlen) 9028ed2b524SDag-Erling Smørgrav { 9038ed2b524SDag-Erling Smørgrav /* uses libNSS */ 9048ed2b524SDag-Erling Smørgrav 9058ed2b524SDag-Erling Smørgrav /* hash prefix for md5, RFC2537 */ 90617d15b25SDag-Erling Smørgrav static unsigned char p_md5[] = {0x30, 0x20, 0x30, 0x0c, 0x06, 0x08, 0x2a, 9078ed2b524SDag-Erling Smørgrav 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x05, 0x05, 0x00, 0x04, 0x10}; 9088ed2b524SDag-Erling Smørgrav /* hash prefix to prepend to hash output, from RFC3110 */ 90917d15b25SDag-Erling Smørgrav static unsigned char p_sha1[] = {0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2B, 9108ed2b524SDag-Erling Smørgrav 0x0E, 0x03, 0x02, 0x1A, 0x05, 0x00, 0x04, 0x14}; 9118ed2b524SDag-Erling Smørgrav /* from RFC5702 */ 91217d15b25SDag-Erling Smørgrav static unsigned char p_sha256[] = {0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 9138ed2b524SDag-Erling Smørgrav 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20}; 91417d15b25SDag-Erling Smørgrav static unsigned char p_sha512[] = {0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 9158ed2b524SDag-Erling Smørgrav 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05, 0x00, 0x04, 0x40}; 9168ed2b524SDag-Erling Smørgrav /* from RFC6234 */ 9178ed2b524SDag-Erling Smørgrav /* for future RSASHA384 .. 91817d15b25SDag-Erling Smørgrav static unsigned char p_sha384[] = {0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 9198ed2b524SDag-Erling Smørgrav 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05, 0x00, 0x04, 0x30}; 9208ed2b524SDag-Erling Smørgrav */ 9218ed2b524SDag-Erling Smørgrav 9228ed2b524SDag-Erling Smørgrav switch(algo) { 9238ed2b524SDag-Erling Smørgrav case LDNS_DSA: 9248ed2b524SDag-Erling Smørgrav case LDNS_DSA_NSEC3: 9258ed2b524SDag-Erling Smørgrav *pubkey = nss_buf2dsa(key, keylen); 9268ed2b524SDag-Erling Smørgrav if(!*pubkey) { 9278ed2b524SDag-Erling Smørgrav log_err("verify: malloc failure in crypto"); 9288ed2b524SDag-Erling Smørgrav return 0; 9298ed2b524SDag-Erling Smørgrav } 9308ed2b524SDag-Erling Smørgrav *htype = HASH_AlgSHA1; 9318ed2b524SDag-Erling Smørgrav /* no prefix for DSA verification */ 9328ed2b524SDag-Erling Smørgrav break; 9338ed2b524SDag-Erling Smørgrav case LDNS_RSASHA1: 9348ed2b524SDag-Erling Smørgrav case LDNS_RSASHA1_NSEC3: 9358ed2b524SDag-Erling Smørgrav #ifdef USE_SHA2 9368ed2b524SDag-Erling Smørgrav case LDNS_RSASHA256: 9378ed2b524SDag-Erling Smørgrav #endif 9388ed2b524SDag-Erling Smørgrav #ifdef USE_SHA2 9398ed2b524SDag-Erling Smørgrav case LDNS_RSASHA512: 9408ed2b524SDag-Erling Smørgrav #endif 9418ed2b524SDag-Erling Smørgrav *pubkey = nss_buf2rsa(key, keylen); 9428ed2b524SDag-Erling Smørgrav if(!*pubkey) { 9438ed2b524SDag-Erling Smørgrav log_err("verify: malloc failure in crypto"); 9448ed2b524SDag-Erling Smørgrav return 0; 9458ed2b524SDag-Erling Smørgrav } 9468ed2b524SDag-Erling Smørgrav /* select SHA version */ 9478ed2b524SDag-Erling Smørgrav #ifdef USE_SHA2 9488ed2b524SDag-Erling Smørgrav if(algo == LDNS_RSASHA256) { 9498ed2b524SDag-Erling Smørgrav *htype = HASH_AlgSHA256; 9508ed2b524SDag-Erling Smørgrav *prefix = p_sha256; 9518ed2b524SDag-Erling Smørgrav *prefixlen = sizeof(p_sha256); 9528ed2b524SDag-Erling Smørgrav } else 9538ed2b524SDag-Erling Smørgrav #endif 9548ed2b524SDag-Erling Smørgrav #ifdef USE_SHA2 9558ed2b524SDag-Erling Smørgrav if(algo == LDNS_RSASHA512) { 9568ed2b524SDag-Erling Smørgrav *htype = HASH_AlgSHA512; 9578ed2b524SDag-Erling Smørgrav *prefix = p_sha512; 9588ed2b524SDag-Erling Smørgrav *prefixlen = sizeof(p_sha512); 9598ed2b524SDag-Erling Smørgrav } else 9608ed2b524SDag-Erling Smørgrav #endif 9618ed2b524SDag-Erling Smørgrav { 9628ed2b524SDag-Erling Smørgrav *htype = HASH_AlgSHA1; 9638ed2b524SDag-Erling Smørgrav *prefix = p_sha1; 9648ed2b524SDag-Erling Smørgrav *prefixlen = sizeof(p_sha1); 9658ed2b524SDag-Erling Smørgrav } 9668ed2b524SDag-Erling Smørgrav 9678ed2b524SDag-Erling Smørgrav break; 9688ed2b524SDag-Erling Smørgrav case LDNS_RSAMD5: 9698ed2b524SDag-Erling Smørgrav *pubkey = nss_buf2rsa(key, keylen); 9708ed2b524SDag-Erling Smørgrav if(!*pubkey) { 9718ed2b524SDag-Erling Smørgrav log_err("verify: malloc failure in crypto"); 9728ed2b524SDag-Erling Smørgrav return 0; 9738ed2b524SDag-Erling Smørgrav } 9748ed2b524SDag-Erling Smørgrav *htype = HASH_AlgMD5; 9758ed2b524SDag-Erling Smørgrav *prefix = p_md5; 9768ed2b524SDag-Erling Smørgrav *prefixlen = sizeof(p_md5); 9778ed2b524SDag-Erling Smørgrav 9788ed2b524SDag-Erling Smørgrav break; 9798ed2b524SDag-Erling Smørgrav #ifdef USE_ECDSA 9808ed2b524SDag-Erling Smørgrav case LDNS_ECDSAP256SHA256: 9818ed2b524SDag-Erling Smørgrav *pubkey = nss_buf2ecdsa(key, keylen, 9828ed2b524SDag-Erling Smørgrav LDNS_ECDSAP256SHA256); 9838ed2b524SDag-Erling Smørgrav if(!*pubkey) { 9848ed2b524SDag-Erling Smørgrav log_err("verify: malloc failure in crypto"); 9858ed2b524SDag-Erling Smørgrav return 0; 9868ed2b524SDag-Erling Smørgrav } 9878ed2b524SDag-Erling Smørgrav *htype = HASH_AlgSHA256; 9888ed2b524SDag-Erling Smørgrav /* no prefix for DSA verification */ 9898ed2b524SDag-Erling Smørgrav break; 9908ed2b524SDag-Erling Smørgrav case LDNS_ECDSAP384SHA384: 9918ed2b524SDag-Erling Smørgrav *pubkey = nss_buf2ecdsa(key, keylen, 9928ed2b524SDag-Erling Smørgrav LDNS_ECDSAP384SHA384); 9938ed2b524SDag-Erling Smørgrav if(!*pubkey) { 9948ed2b524SDag-Erling Smørgrav log_err("verify: malloc failure in crypto"); 9958ed2b524SDag-Erling Smørgrav return 0; 9968ed2b524SDag-Erling Smørgrav } 9978ed2b524SDag-Erling Smørgrav *htype = HASH_AlgSHA384; 9988ed2b524SDag-Erling Smørgrav /* no prefix for DSA verification */ 9998ed2b524SDag-Erling Smørgrav break; 10008ed2b524SDag-Erling Smørgrav #endif /* USE_ECDSA */ 10018ed2b524SDag-Erling Smørgrav case LDNS_ECC_GOST: 10028ed2b524SDag-Erling Smørgrav default: 10038ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: unknown algorithm %d", 10048ed2b524SDag-Erling Smørgrav algo); 10058ed2b524SDag-Erling Smørgrav return 0; 10068ed2b524SDag-Erling Smørgrav } 10078ed2b524SDag-Erling Smørgrav return 1; 10088ed2b524SDag-Erling Smørgrav } 10098ed2b524SDag-Erling Smørgrav 10108ed2b524SDag-Erling Smørgrav /** 10118ed2b524SDag-Erling Smørgrav * Check a canonical sig+rrset and signature against a dnskey 10128ed2b524SDag-Erling Smørgrav * @param buf: buffer with data to verify, the first rrsig part and the 10138ed2b524SDag-Erling Smørgrav * canonicalized rrset. 10148ed2b524SDag-Erling Smørgrav * @param algo: DNSKEY algorithm. 10158ed2b524SDag-Erling Smørgrav * @param sigblock: signature rdata field from RRSIG 10168ed2b524SDag-Erling Smørgrav * @param sigblock_len: length of sigblock data. 10178ed2b524SDag-Erling Smørgrav * @param key: public key data from DNSKEY RR. 10188ed2b524SDag-Erling Smørgrav * @param keylen: length of keydata. 10198ed2b524SDag-Erling Smørgrav * @param reason: bogus reason in more detail. 10208ed2b524SDag-Erling Smørgrav * @return secure if verification succeeded, bogus on crypto failure, 10218ed2b524SDag-Erling Smørgrav * unchecked on format errors and alloc failures. 10228ed2b524SDag-Erling Smørgrav */ 10238ed2b524SDag-Erling Smørgrav enum sec_status 102417d15b25SDag-Erling Smørgrav verify_canonrrset(sldns_buffer* buf, int algo, unsigned char* sigblock, 10258ed2b524SDag-Erling Smørgrav unsigned int sigblock_len, unsigned char* key, unsigned int keylen, 10268ed2b524SDag-Erling Smørgrav char** reason) 10278ed2b524SDag-Erling Smørgrav { 10288ed2b524SDag-Erling Smørgrav /* uses libNSS */ 10298ed2b524SDag-Erling Smørgrav /* large enough for the different hashes */ 10308ed2b524SDag-Erling Smørgrav unsigned char hash[HASH_LENGTH_MAX]; 10318ed2b524SDag-Erling Smørgrav unsigned char hash2[HASH_LENGTH_MAX*2]; 10328ed2b524SDag-Erling Smørgrav HASH_HashType htype = 0; 10338ed2b524SDag-Erling Smørgrav SECKEYPublicKey* pubkey = NULL; 10348ed2b524SDag-Erling Smørgrav SECItem secsig = {siBuffer, sigblock, sigblock_len}; 10358ed2b524SDag-Erling Smørgrav SECItem sechash = {siBuffer, hash, 0}; 10368ed2b524SDag-Erling Smørgrav SECStatus res; 10378ed2b524SDag-Erling Smørgrav unsigned char* prefix = NULL; /* prefix for hash, RFC3110, RFC5702 */ 10388ed2b524SDag-Erling Smørgrav size_t prefixlen = 0; 10398ed2b524SDag-Erling Smørgrav int err; 10408ed2b524SDag-Erling Smørgrav 10418ed2b524SDag-Erling Smørgrav if(!nss_setup_key_digest(algo, &pubkey, &htype, key, keylen, 10428ed2b524SDag-Erling Smørgrav &prefix, &prefixlen)) { 10438ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: failed to setup key"); 10448ed2b524SDag-Erling Smørgrav *reason = "use of key for crypto failed"; 10458ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pubkey); 10468ed2b524SDag-Erling Smørgrav return sec_status_bogus; 10478ed2b524SDag-Erling Smørgrav } 10488ed2b524SDag-Erling Smørgrav 10498ed2b524SDag-Erling Smørgrav /* need to convert DSA, ECDSA signatures? */ 10508ed2b524SDag-Erling Smørgrav if((algo == LDNS_DSA || algo == LDNS_DSA_NSEC3)) { 10518ed2b524SDag-Erling Smørgrav if(sigblock_len == 1+2*SHA1_LENGTH) { 10528ed2b524SDag-Erling Smørgrav secsig.data ++; 10538ed2b524SDag-Erling Smørgrav secsig.len --; 10548ed2b524SDag-Erling Smørgrav } else { 10558ed2b524SDag-Erling Smørgrav SECItem* p = DSAU_DecodeDerSig(&secsig); 10568ed2b524SDag-Erling Smørgrav if(!p) { 10578ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: failed DER decode"); 10588ed2b524SDag-Erling Smørgrav *reason = "signature DER decode failed"; 10598ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pubkey); 10608ed2b524SDag-Erling Smørgrav return sec_status_bogus; 10618ed2b524SDag-Erling Smørgrav } 10628ed2b524SDag-Erling Smørgrav if(SECITEM_CopyItem(pubkey->arena, &secsig, p)) { 10638ed2b524SDag-Erling Smørgrav log_err("alloc failure in DER decode"); 10648ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pubkey); 10658ed2b524SDag-Erling Smørgrav SECITEM_FreeItem(p, PR_TRUE); 10668ed2b524SDag-Erling Smørgrav return sec_status_unchecked; 10678ed2b524SDag-Erling Smørgrav } 10688ed2b524SDag-Erling Smørgrav SECITEM_FreeItem(p, PR_TRUE); 10698ed2b524SDag-Erling Smørgrav } 10708ed2b524SDag-Erling Smørgrav } 10718ed2b524SDag-Erling Smørgrav 10728ed2b524SDag-Erling Smørgrav /* do the signature cryptography work */ 10738ed2b524SDag-Erling Smørgrav /* hash the data */ 10748ed2b524SDag-Erling Smørgrav sechash.len = HASH_ResultLen(htype); 10758ed2b524SDag-Erling Smørgrav if(sechash.len > sizeof(hash)) { 10768ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: hash too large for buffer"); 10778ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pubkey); 10788ed2b524SDag-Erling Smørgrav return sec_status_unchecked; 10798ed2b524SDag-Erling Smørgrav } 108017d15b25SDag-Erling Smørgrav if(HASH_HashBuf(htype, hash, (unsigned char*)sldns_buffer_begin(buf), 108117d15b25SDag-Erling Smørgrav (unsigned int)sldns_buffer_limit(buf)) != SECSuccess) { 10828ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: HASH_HashBuf failed"); 10838ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pubkey); 10848ed2b524SDag-Erling Smørgrav return sec_status_unchecked; 10858ed2b524SDag-Erling Smørgrav } 10868ed2b524SDag-Erling Smørgrav if(prefix) { 10878ed2b524SDag-Erling Smørgrav int hashlen = sechash.len; 10888ed2b524SDag-Erling Smørgrav if(prefixlen+hashlen > sizeof(hash2)) { 10898ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: hashprefix too large"); 10908ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pubkey); 10918ed2b524SDag-Erling Smørgrav return sec_status_unchecked; 10928ed2b524SDag-Erling Smørgrav } 10938ed2b524SDag-Erling Smørgrav sechash.data = hash2; 10948ed2b524SDag-Erling Smørgrav sechash.len = prefixlen+hashlen; 10958ed2b524SDag-Erling Smørgrav memcpy(sechash.data, prefix, prefixlen); 10968ed2b524SDag-Erling Smørgrav memmove(sechash.data+prefixlen, hash, hashlen); 10978ed2b524SDag-Erling Smørgrav } 10988ed2b524SDag-Erling Smørgrav 10998ed2b524SDag-Erling Smørgrav /* verify the signature */ 11008ed2b524SDag-Erling Smørgrav res = PK11_Verify(pubkey, &secsig, &sechash, NULL /*wincx*/); 11018ed2b524SDag-Erling Smørgrav SECKEY_DestroyPublicKey(pubkey); 11028ed2b524SDag-Erling Smørgrav 11038ed2b524SDag-Erling Smørgrav if(res == SECSuccess) { 11048ed2b524SDag-Erling Smørgrav return sec_status_secure; 11058ed2b524SDag-Erling Smørgrav } 11068ed2b524SDag-Erling Smørgrav err = PORT_GetError(); 11078ed2b524SDag-Erling Smørgrav if(err != SEC_ERROR_BAD_SIGNATURE) { 11088ed2b524SDag-Erling Smørgrav /* failed to verify */ 11098ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: PK11_Verify failed: %s", 11108ed2b524SDag-Erling Smørgrav PORT_ErrorToString(err)); 11118ed2b524SDag-Erling Smørgrav /* if it is not supported, like ECC is removed, we get, 11128ed2b524SDag-Erling Smørgrav * SEC_ERROR_NO_MODULE */ 11138ed2b524SDag-Erling Smørgrav if(err == SEC_ERROR_NO_MODULE) 11148ed2b524SDag-Erling Smørgrav return sec_status_unchecked; 11158ed2b524SDag-Erling Smørgrav /* but other errors are commonly returned 11168ed2b524SDag-Erling Smørgrav * for a bad signature from NSS. Thus we return bogus, 11178ed2b524SDag-Erling Smørgrav * not unchecked */ 11188ed2b524SDag-Erling Smørgrav *reason = "signature crypto failed"; 11198ed2b524SDag-Erling Smørgrav return sec_status_bogus; 11208ed2b524SDag-Erling Smørgrav } 11218ed2b524SDag-Erling Smørgrav verbose(VERB_QUERY, "verify: signature mismatch: %s", 11228ed2b524SDag-Erling Smørgrav PORT_ErrorToString(err)); 11238ed2b524SDag-Erling Smørgrav *reason = "signature crypto failed"; 11248ed2b524SDag-Erling Smørgrav return sec_status_bogus; 11258ed2b524SDag-Erling Smørgrav } 11268ed2b524SDag-Erling Smørgrav 112705ab2901SDag-Erling Smørgrav #elif defined(HAVE_NETTLE) 11288ed2b524SDag-Erling Smørgrav 112905ab2901SDag-Erling Smørgrav #include "sha.h" 113005ab2901SDag-Erling Smørgrav #include "bignum.h" 113105ab2901SDag-Erling Smørgrav #include "macros.h" 113205ab2901SDag-Erling Smørgrav #include "rsa.h" 113305ab2901SDag-Erling Smørgrav #include "dsa.h" 113405ab2901SDag-Erling Smørgrav #include "asn1.h" 113505ab2901SDag-Erling Smørgrav #ifdef USE_ECDSA 113605ab2901SDag-Erling Smørgrav #include "ecdsa.h" 113705ab2901SDag-Erling Smørgrav #include "ecc-curve.h" 113805ab2901SDag-Erling Smørgrav #endif 113905ab2901SDag-Erling Smørgrav 114005ab2901SDag-Erling Smørgrav static int 114105ab2901SDag-Erling Smørgrav _digest_nettle(int algo, uint8_t* buf, size_t len, 114205ab2901SDag-Erling Smørgrav unsigned char* res) 114305ab2901SDag-Erling Smørgrav { 114405ab2901SDag-Erling Smørgrav switch(algo) { 114505ab2901SDag-Erling Smørgrav case SHA1_DIGEST_SIZE: 114605ab2901SDag-Erling Smørgrav { 114705ab2901SDag-Erling Smørgrav struct sha1_ctx ctx; 114805ab2901SDag-Erling Smørgrav sha1_init(&ctx); 114905ab2901SDag-Erling Smørgrav sha1_update(&ctx, len, buf); 115005ab2901SDag-Erling Smørgrav sha1_digest(&ctx, SHA1_DIGEST_SIZE, res); 115105ab2901SDag-Erling Smørgrav return 1; 115205ab2901SDag-Erling Smørgrav } 115305ab2901SDag-Erling Smørgrav case SHA256_DIGEST_SIZE: 115405ab2901SDag-Erling Smørgrav { 115505ab2901SDag-Erling Smørgrav struct sha256_ctx ctx; 115605ab2901SDag-Erling Smørgrav sha256_init(&ctx); 115705ab2901SDag-Erling Smørgrav sha256_update(&ctx, len, buf); 115805ab2901SDag-Erling Smørgrav sha256_digest(&ctx, SHA256_DIGEST_SIZE, res); 115905ab2901SDag-Erling Smørgrav return 1; 116005ab2901SDag-Erling Smørgrav } 116105ab2901SDag-Erling Smørgrav case SHA384_DIGEST_SIZE: 116205ab2901SDag-Erling Smørgrav { 116305ab2901SDag-Erling Smørgrav struct sha384_ctx ctx; 116405ab2901SDag-Erling Smørgrav sha384_init(&ctx); 116505ab2901SDag-Erling Smørgrav sha384_update(&ctx, len, buf); 116605ab2901SDag-Erling Smørgrav sha384_digest(&ctx, SHA384_DIGEST_SIZE, res); 116705ab2901SDag-Erling Smørgrav return 1; 116805ab2901SDag-Erling Smørgrav } 116905ab2901SDag-Erling Smørgrav case SHA512_DIGEST_SIZE: 117005ab2901SDag-Erling Smørgrav { 117105ab2901SDag-Erling Smørgrav struct sha512_ctx ctx; 117205ab2901SDag-Erling Smørgrav sha512_init(&ctx); 117305ab2901SDag-Erling Smørgrav sha512_update(&ctx, len, buf); 117405ab2901SDag-Erling Smørgrav sha512_digest(&ctx, SHA512_DIGEST_SIZE, res); 117505ab2901SDag-Erling Smørgrav return 1; 117605ab2901SDag-Erling Smørgrav } 117705ab2901SDag-Erling Smørgrav default: 117805ab2901SDag-Erling Smørgrav break; 117905ab2901SDag-Erling Smørgrav } 118005ab2901SDag-Erling Smørgrav return 0; 118105ab2901SDag-Erling Smørgrav } 118205ab2901SDag-Erling Smørgrav 118305ab2901SDag-Erling Smørgrav /* return size of digest if supported, or 0 otherwise */ 118405ab2901SDag-Erling Smørgrav size_t 118505ab2901SDag-Erling Smørgrav nsec3_hash_algo_size_supported(int id) 118605ab2901SDag-Erling Smørgrav { 118705ab2901SDag-Erling Smørgrav switch(id) { 118805ab2901SDag-Erling Smørgrav case NSEC3_HASH_SHA1: 118905ab2901SDag-Erling Smørgrav return SHA1_DIGEST_SIZE; 119005ab2901SDag-Erling Smørgrav default: 119105ab2901SDag-Erling Smørgrav return 0; 119205ab2901SDag-Erling Smørgrav } 119305ab2901SDag-Erling Smørgrav } 119405ab2901SDag-Erling Smørgrav 119505ab2901SDag-Erling Smørgrav /* perform nsec3 hash. return false on failure */ 119605ab2901SDag-Erling Smørgrav int 119705ab2901SDag-Erling Smørgrav secalgo_nsec3_hash(int algo, unsigned char* buf, size_t len, 119805ab2901SDag-Erling Smørgrav unsigned char* res) 119905ab2901SDag-Erling Smørgrav { 120005ab2901SDag-Erling Smørgrav switch(algo) { 120105ab2901SDag-Erling Smørgrav case NSEC3_HASH_SHA1: 120205ab2901SDag-Erling Smørgrav return _digest_nettle(SHA1_DIGEST_SIZE, (uint8_t*)buf, len, 120305ab2901SDag-Erling Smørgrav res); 120405ab2901SDag-Erling Smørgrav default: 120505ab2901SDag-Erling Smørgrav return 0; 120605ab2901SDag-Erling Smørgrav } 120705ab2901SDag-Erling Smørgrav } 120805ab2901SDag-Erling Smørgrav 120905ab2901SDag-Erling Smørgrav /** 121005ab2901SDag-Erling Smørgrav * Return size of DS digest according to its hash algorithm. 121105ab2901SDag-Erling Smørgrav * @param algo: DS digest algo. 121205ab2901SDag-Erling Smørgrav * @return size in bytes of digest, or 0 if not supported. 121305ab2901SDag-Erling Smørgrav */ 121405ab2901SDag-Erling Smørgrav size_t 121505ab2901SDag-Erling Smørgrav ds_digest_size_supported(int algo) 121605ab2901SDag-Erling Smørgrav { 121705ab2901SDag-Erling Smørgrav switch(algo) { 121805ab2901SDag-Erling Smørgrav case LDNS_SHA1: 121905ab2901SDag-Erling Smørgrav return SHA1_DIGEST_SIZE; 122005ab2901SDag-Erling Smørgrav #ifdef USE_SHA2 122105ab2901SDag-Erling Smørgrav case LDNS_SHA256: 122205ab2901SDag-Erling Smørgrav return SHA256_DIGEST_SIZE; 122305ab2901SDag-Erling Smørgrav #endif 122405ab2901SDag-Erling Smørgrav #ifdef USE_ECDSA 122505ab2901SDag-Erling Smørgrav case LDNS_SHA384: 122605ab2901SDag-Erling Smørgrav return SHA384_DIGEST_SIZE; 122705ab2901SDag-Erling Smørgrav #endif 122805ab2901SDag-Erling Smørgrav /* GOST not supported */ 122905ab2901SDag-Erling Smørgrav case LDNS_HASH_GOST: 123005ab2901SDag-Erling Smørgrav default: 123105ab2901SDag-Erling Smørgrav break; 123205ab2901SDag-Erling Smørgrav } 123305ab2901SDag-Erling Smørgrav return 0; 123405ab2901SDag-Erling Smørgrav } 123505ab2901SDag-Erling Smørgrav 123605ab2901SDag-Erling Smørgrav int 123705ab2901SDag-Erling Smørgrav secalgo_ds_digest(int algo, unsigned char* buf, size_t len, 123805ab2901SDag-Erling Smørgrav unsigned char* res) 123905ab2901SDag-Erling Smørgrav { 124005ab2901SDag-Erling Smørgrav switch(algo) { 124105ab2901SDag-Erling Smørgrav case LDNS_SHA1: 124205ab2901SDag-Erling Smørgrav return _digest_nettle(SHA1_DIGEST_SIZE, buf, len, res); 124305ab2901SDag-Erling Smørgrav #if defined(USE_SHA2) 124405ab2901SDag-Erling Smørgrav case LDNS_SHA256: 124505ab2901SDag-Erling Smørgrav return _digest_nettle(SHA256_DIGEST_SIZE, buf, len, res); 124605ab2901SDag-Erling Smørgrav #endif 124705ab2901SDag-Erling Smørgrav #ifdef USE_ECDSA 124805ab2901SDag-Erling Smørgrav case LDNS_SHA384: 124905ab2901SDag-Erling Smørgrav return _digest_nettle(SHA384_DIGEST_SIZE, buf, len, res); 125005ab2901SDag-Erling Smørgrav 125105ab2901SDag-Erling Smørgrav #endif 125205ab2901SDag-Erling Smørgrav case LDNS_HASH_GOST: 125305ab2901SDag-Erling Smørgrav default: 125405ab2901SDag-Erling Smørgrav verbose(VERB_QUERY, "unknown DS digest algorithm %d", 125505ab2901SDag-Erling Smørgrav algo); 125605ab2901SDag-Erling Smørgrav break; 125705ab2901SDag-Erling Smørgrav } 125805ab2901SDag-Erling Smørgrav return 0; 125905ab2901SDag-Erling Smørgrav } 126005ab2901SDag-Erling Smørgrav 126105ab2901SDag-Erling Smørgrav int 126205ab2901SDag-Erling Smørgrav dnskey_algo_id_is_supported(int id) 126305ab2901SDag-Erling Smørgrav { 126405ab2901SDag-Erling Smørgrav /* uses libnettle */ 126505ab2901SDag-Erling Smørgrav switch(id) { 126605ab2901SDag-Erling Smørgrav case LDNS_DSA: 126705ab2901SDag-Erling Smørgrav case LDNS_DSA_NSEC3: 126805ab2901SDag-Erling Smørgrav case LDNS_RSASHA1: 126905ab2901SDag-Erling Smørgrav case LDNS_RSASHA1_NSEC3: 127005ab2901SDag-Erling Smørgrav #ifdef USE_SHA2 127105ab2901SDag-Erling Smørgrav case LDNS_RSASHA256: 127205ab2901SDag-Erling Smørgrav case LDNS_RSASHA512: 127305ab2901SDag-Erling Smørgrav #endif 127405ab2901SDag-Erling Smørgrav #ifdef USE_ECDSA 127505ab2901SDag-Erling Smørgrav case LDNS_ECDSAP256SHA256: 127605ab2901SDag-Erling Smørgrav case LDNS_ECDSAP384SHA384: 127705ab2901SDag-Erling Smørgrav #endif 127805ab2901SDag-Erling Smørgrav return 1; 127905ab2901SDag-Erling Smørgrav case LDNS_RSAMD5: /* RFC 6725 deprecates RSAMD5 */ 128005ab2901SDag-Erling Smørgrav case LDNS_ECC_GOST: 128105ab2901SDag-Erling Smørgrav default: 128205ab2901SDag-Erling Smørgrav return 0; 128305ab2901SDag-Erling Smørgrav } 128405ab2901SDag-Erling Smørgrav } 128505ab2901SDag-Erling Smørgrav 128605ab2901SDag-Erling Smørgrav static char * 128705ab2901SDag-Erling Smørgrav _verify_nettle_dsa(sldns_buffer* buf, unsigned char* sigblock, 128805ab2901SDag-Erling Smørgrav unsigned int sigblock_len, unsigned char* key, unsigned int keylen) 128905ab2901SDag-Erling Smørgrav { 129005ab2901SDag-Erling Smørgrav uint8_t digest[SHA1_DIGEST_SIZE]; 129105ab2901SDag-Erling Smørgrav uint8_t key_t; 129205ab2901SDag-Erling Smørgrav int res = 0; 129305ab2901SDag-Erling Smørgrav size_t offset; 129405ab2901SDag-Erling Smørgrav struct dsa_public_key pubkey; 129505ab2901SDag-Erling Smørgrav struct dsa_signature signature; 129605ab2901SDag-Erling Smørgrav unsigned int expected_len; 129705ab2901SDag-Erling Smørgrav 129805ab2901SDag-Erling Smørgrav /* Extract DSA signature from the record */ 129905ab2901SDag-Erling Smørgrav nettle_dsa_signature_init(&signature); 130005ab2901SDag-Erling Smørgrav /* Signature length: 41 bytes - RFC 2536 sec. 3 */ 130105ab2901SDag-Erling Smørgrav if(sigblock_len == 41) { 130205ab2901SDag-Erling Smørgrav if(key[0] != sigblock[0]) 130305ab2901SDag-Erling Smørgrav return "invalid T value in DSA signature or pubkey"; 130405ab2901SDag-Erling Smørgrav nettle_mpz_set_str_256_u(signature.r, 20, sigblock+1); 130505ab2901SDag-Erling Smørgrav nettle_mpz_set_str_256_u(signature.s, 20, sigblock+1+20); 130605ab2901SDag-Erling Smørgrav } else { 130705ab2901SDag-Erling Smørgrav /* DER encoded, decode the ASN1 notated R and S bignums */ 130805ab2901SDag-Erling Smørgrav /* SEQUENCE { r INTEGER, s INTEGER } */ 130905ab2901SDag-Erling Smørgrav struct asn1_der_iterator i, seq; 131005ab2901SDag-Erling Smørgrav if(asn1_der_iterator_first(&i, sigblock_len, 131105ab2901SDag-Erling Smørgrav (uint8_t*)sigblock) != ASN1_ITERATOR_CONSTRUCTED 131205ab2901SDag-Erling Smørgrav || i.type != ASN1_SEQUENCE) 131305ab2901SDag-Erling Smørgrav return "malformed DER encoded DSA signature"; 131405ab2901SDag-Erling Smørgrav /* decode this element of i using the seq iterator */ 131505ab2901SDag-Erling Smørgrav if(asn1_der_decode_constructed(&i, &seq) != 131605ab2901SDag-Erling Smørgrav ASN1_ITERATOR_PRIMITIVE || seq.type != ASN1_INTEGER) 131705ab2901SDag-Erling Smørgrav return "malformed DER encoded DSA signature"; 131805ab2901SDag-Erling Smørgrav if(!asn1_der_get_bignum(&seq, signature.r, 20*8)) 131905ab2901SDag-Erling Smørgrav return "malformed DER encoded DSA signature"; 132005ab2901SDag-Erling Smørgrav if(asn1_der_iterator_next(&seq) != ASN1_ITERATOR_PRIMITIVE 132105ab2901SDag-Erling Smørgrav || seq.type != ASN1_INTEGER) 132205ab2901SDag-Erling Smørgrav return "malformed DER encoded DSA signature"; 132305ab2901SDag-Erling Smørgrav if(!asn1_der_get_bignum(&seq, signature.s, 20*8)) 132405ab2901SDag-Erling Smørgrav return "malformed DER encoded DSA signature"; 132505ab2901SDag-Erling Smørgrav if(asn1_der_iterator_next(&i) != ASN1_ITERATOR_END) 132605ab2901SDag-Erling Smørgrav return "malformed DER encoded DSA signature"; 132705ab2901SDag-Erling Smørgrav } 132805ab2901SDag-Erling Smørgrav 132905ab2901SDag-Erling Smørgrav /* Validate T values constraints - RFC 2536 sec. 2 & sec. 3 */ 133005ab2901SDag-Erling Smørgrav key_t = key[0]; 133105ab2901SDag-Erling Smørgrav if (key_t > 8) { 133205ab2901SDag-Erling Smørgrav return "invalid T value in DSA pubkey"; 133305ab2901SDag-Erling Smørgrav } 133405ab2901SDag-Erling Smørgrav 133505ab2901SDag-Erling Smørgrav /* Pubkey minimum length: 21 bytes - RFC 2536 sec. 2 */ 133605ab2901SDag-Erling Smørgrav if (keylen < 21) { 133705ab2901SDag-Erling Smørgrav return "DSA pubkey too short"; 133805ab2901SDag-Erling Smørgrav } 133905ab2901SDag-Erling Smørgrav 134005ab2901SDag-Erling Smørgrav expected_len = 1 + /* T */ 134105ab2901SDag-Erling Smørgrav 20 + /* Q */ 134205ab2901SDag-Erling Smørgrav (64 + key_t*8) + /* P */ 134305ab2901SDag-Erling Smørgrav (64 + key_t*8) + /* G */ 134405ab2901SDag-Erling Smørgrav (64 + key_t*8); /* Y */ 134505ab2901SDag-Erling Smørgrav if (keylen != expected_len ) { 134605ab2901SDag-Erling Smørgrav return "invalid DSA pubkey length"; 134705ab2901SDag-Erling Smørgrav } 134805ab2901SDag-Erling Smørgrav 134905ab2901SDag-Erling Smørgrav /* Extract DSA pubkey from the record */ 135005ab2901SDag-Erling Smørgrav nettle_dsa_public_key_init(&pubkey); 135105ab2901SDag-Erling Smørgrav offset = 1; 135205ab2901SDag-Erling Smørgrav nettle_mpz_set_str_256_u(pubkey.q, 20, key+offset); 135305ab2901SDag-Erling Smørgrav offset += 20; 135405ab2901SDag-Erling Smørgrav nettle_mpz_set_str_256_u(pubkey.p, (64 + key_t*8), key+offset); 135505ab2901SDag-Erling Smørgrav offset += (64 + key_t*8); 135605ab2901SDag-Erling Smørgrav nettle_mpz_set_str_256_u(pubkey.g, (64 + key_t*8), key+offset); 135705ab2901SDag-Erling Smørgrav offset += (64 + key_t*8); 135805ab2901SDag-Erling Smørgrav nettle_mpz_set_str_256_u(pubkey.y, (64 + key_t*8), key+offset); 135905ab2901SDag-Erling Smørgrav 136005ab2901SDag-Erling Smørgrav /* Digest content of "buf" and verify its DSA signature in "sigblock"*/ 136105ab2901SDag-Erling Smørgrav res = _digest_nettle(SHA1_DIGEST_SIZE, (unsigned char*)sldns_buffer_begin(buf), 136205ab2901SDag-Erling Smørgrav (unsigned int)sldns_buffer_limit(buf), (unsigned char*)digest); 136305ab2901SDag-Erling Smørgrav res &= dsa_sha1_verify_digest(&pubkey, digest, &signature); 136405ab2901SDag-Erling Smørgrav 136505ab2901SDag-Erling Smørgrav /* Clear and return */ 136605ab2901SDag-Erling Smørgrav nettle_dsa_signature_clear(&signature); 136705ab2901SDag-Erling Smørgrav nettle_dsa_public_key_clear(&pubkey); 136805ab2901SDag-Erling Smørgrav if (!res) 136905ab2901SDag-Erling Smørgrav return "DSA signature verification failed"; 137005ab2901SDag-Erling Smørgrav else 137105ab2901SDag-Erling Smørgrav return NULL; 137205ab2901SDag-Erling Smørgrav } 137305ab2901SDag-Erling Smørgrav 137405ab2901SDag-Erling Smørgrav static char * 137505ab2901SDag-Erling Smørgrav _verify_nettle_rsa(sldns_buffer* buf, unsigned int digest_size, char* sigblock, 137605ab2901SDag-Erling Smørgrav unsigned int sigblock_len, uint8_t* key, unsigned int keylen) 137705ab2901SDag-Erling Smørgrav { 137805ab2901SDag-Erling Smørgrav uint16_t exp_len = 0; 137905ab2901SDag-Erling Smørgrav size_t exp_offset = 0, mod_offset = 0; 138005ab2901SDag-Erling Smørgrav struct rsa_public_key pubkey; 138105ab2901SDag-Erling Smørgrav mpz_t signature; 138205ab2901SDag-Erling Smørgrav int res = 0; 138305ab2901SDag-Erling Smørgrav 138405ab2901SDag-Erling Smørgrav /* RSA pubkey parsing as per RFC 3110 sec. 2 */ 138505ab2901SDag-Erling Smørgrav if( keylen <= 1) { 138605ab2901SDag-Erling Smørgrav return "null RSA key"; 138705ab2901SDag-Erling Smørgrav } 138805ab2901SDag-Erling Smørgrav if (key[0] != 0) { 138905ab2901SDag-Erling Smørgrav /* 1-byte length */ 139005ab2901SDag-Erling Smørgrav exp_len = key[0]; 139105ab2901SDag-Erling Smørgrav exp_offset = 1; 139205ab2901SDag-Erling Smørgrav } else { 139305ab2901SDag-Erling Smørgrav /* 1-byte NUL + 2-bytes exponent length */ 139405ab2901SDag-Erling Smørgrav if (keylen < 3) { 139505ab2901SDag-Erling Smørgrav return "incorrect RSA key length"; 139605ab2901SDag-Erling Smørgrav } 139705ab2901SDag-Erling Smørgrav exp_len = READ_UINT16(key+1); 139805ab2901SDag-Erling Smørgrav if (exp_len == 0) 139905ab2901SDag-Erling Smørgrav return "null RSA exponent length"; 140005ab2901SDag-Erling Smørgrav exp_offset = 3; 140105ab2901SDag-Erling Smørgrav } 140205ab2901SDag-Erling Smørgrav /* Check that we are not over-running input length */ 140305ab2901SDag-Erling Smørgrav if (keylen < exp_offset + exp_len + 1) { 140405ab2901SDag-Erling Smørgrav return "RSA key content shorter than expected"; 140505ab2901SDag-Erling Smørgrav } 140605ab2901SDag-Erling Smørgrav mod_offset = exp_offset + exp_len; 140705ab2901SDag-Erling Smørgrav nettle_rsa_public_key_init(&pubkey); 140805ab2901SDag-Erling Smørgrav pubkey.size = keylen - mod_offset; 140905ab2901SDag-Erling Smørgrav nettle_mpz_set_str_256_u(pubkey.e, exp_len, &key[exp_offset]); 141005ab2901SDag-Erling Smørgrav nettle_mpz_set_str_256_u(pubkey.n, pubkey.size, &key[mod_offset]); 141105ab2901SDag-Erling Smørgrav 141205ab2901SDag-Erling Smørgrav /* Digest content of "buf" and verify its RSA signature in "sigblock"*/ 141305ab2901SDag-Erling Smørgrav nettle_mpz_init_set_str_256_u(signature, sigblock_len, (uint8_t*)sigblock); 141405ab2901SDag-Erling Smørgrav switch (digest_size) { 141505ab2901SDag-Erling Smørgrav case SHA1_DIGEST_SIZE: 141605ab2901SDag-Erling Smørgrav { 141705ab2901SDag-Erling Smørgrav uint8_t digest[SHA1_DIGEST_SIZE]; 141805ab2901SDag-Erling Smørgrav res = _digest_nettle(SHA1_DIGEST_SIZE, (unsigned char*)sldns_buffer_begin(buf), 141905ab2901SDag-Erling Smørgrav (unsigned int)sldns_buffer_limit(buf), (unsigned char*)digest); 142005ab2901SDag-Erling Smørgrav res &= rsa_sha1_verify_digest(&pubkey, digest, signature); 142105ab2901SDag-Erling Smørgrav break; 142205ab2901SDag-Erling Smørgrav } 142305ab2901SDag-Erling Smørgrav case SHA256_DIGEST_SIZE: 142405ab2901SDag-Erling Smørgrav { 142505ab2901SDag-Erling Smørgrav uint8_t digest[SHA256_DIGEST_SIZE]; 142605ab2901SDag-Erling Smørgrav res = _digest_nettle(SHA256_DIGEST_SIZE, (unsigned char*)sldns_buffer_begin(buf), 142705ab2901SDag-Erling Smørgrav (unsigned int)sldns_buffer_limit(buf), (unsigned char*)digest); 142805ab2901SDag-Erling Smørgrav res &= rsa_sha256_verify_digest(&pubkey, digest, signature); 142905ab2901SDag-Erling Smørgrav break; 143005ab2901SDag-Erling Smørgrav } 143105ab2901SDag-Erling Smørgrav case SHA512_DIGEST_SIZE: 143205ab2901SDag-Erling Smørgrav { 143305ab2901SDag-Erling Smørgrav uint8_t digest[SHA512_DIGEST_SIZE]; 143405ab2901SDag-Erling Smørgrav res = _digest_nettle(SHA512_DIGEST_SIZE, (unsigned char*)sldns_buffer_begin(buf), 143505ab2901SDag-Erling Smørgrav (unsigned int)sldns_buffer_limit(buf), (unsigned char*)digest); 143605ab2901SDag-Erling Smørgrav res &= rsa_sha512_verify_digest(&pubkey, digest, signature); 143705ab2901SDag-Erling Smørgrav break; 143805ab2901SDag-Erling Smørgrav } 143905ab2901SDag-Erling Smørgrav default: 144005ab2901SDag-Erling Smørgrav break; 144105ab2901SDag-Erling Smørgrav } 144205ab2901SDag-Erling Smørgrav 144305ab2901SDag-Erling Smørgrav /* Clear and return */ 144405ab2901SDag-Erling Smørgrav nettle_rsa_public_key_clear(&pubkey); 144505ab2901SDag-Erling Smørgrav mpz_clear(signature); 144605ab2901SDag-Erling Smørgrav if (!res) { 144705ab2901SDag-Erling Smørgrav return "RSA signature verification failed"; 144805ab2901SDag-Erling Smørgrav } else { 144905ab2901SDag-Erling Smørgrav return NULL; 145005ab2901SDag-Erling Smørgrav } 145105ab2901SDag-Erling Smørgrav } 145205ab2901SDag-Erling Smørgrav 145305ab2901SDag-Erling Smørgrav #ifdef USE_ECDSA 145405ab2901SDag-Erling Smørgrav static char * 145505ab2901SDag-Erling Smørgrav _verify_nettle_ecdsa(sldns_buffer* buf, unsigned int digest_size, unsigned char* sigblock, 145605ab2901SDag-Erling Smørgrav unsigned int sigblock_len, unsigned char* key, unsigned int keylen) 145705ab2901SDag-Erling Smørgrav { 145805ab2901SDag-Erling Smørgrav int res = 0; 145905ab2901SDag-Erling Smørgrav struct ecc_point pubkey; 146005ab2901SDag-Erling Smørgrav struct dsa_signature signature; 146105ab2901SDag-Erling Smørgrav 146205ab2901SDag-Erling Smørgrav /* Always matched strength, as per RFC 6605 sec. 1 */ 146305ab2901SDag-Erling Smørgrav if (sigblock_len != 2*digest_size || keylen != 2*digest_size) { 146405ab2901SDag-Erling Smørgrav return "wrong ECDSA signature length"; 146505ab2901SDag-Erling Smørgrav } 146605ab2901SDag-Erling Smørgrav 146705ab2901SDag-Erling Smørgrav /* Parse ECDSA signature as per RFC 6605 sec. 4 */ 146805ab2901SDag-Erling Smørgrav nettle_dsa_signature_init(&signature); 146905ab2901SDag-Erling Smørgrav switch (digest_size) { 147005ab2901SDag-Erling Smørgrav case SHA256_DIGEST_SIZE: 147105ab2901SDag-Erling Smørgrav { 147205ab2901SDag-Erling Smørgrav uint8_t digest[SHA256_DIGEST_SIZE]; 147305ab2901SDag-Erling Smørgrav mpz_t x, y; 147405ab2901SDag-Erling Smørgrav nettle_ecc_point_init(&pubkey, &nettle_secp_256r1); 147505ab2901SDag-Erling Smørgrav nettle_mpz_init_set_str_256_u(x, SHA256_DIGEST_SIZE, key); 147605ab2901SDag-Erling Smørgrav nettle_mpz_init_set_str_256_u(y, SHA256_DIGEST_SIZE, key+SHA256_DIGEST_SIZE); 147705ab2901SDag-Erling Smørgrav nettle_mpz_set_str_256_u(signature.r, SHA256_DIGEST_SIZE, sigblock); 147805ab2901SDag-Erling Smørgrav nettle_mpz_set_str_256_u(signature.s, SHA256_DIGEST_SIZE, sigblock+SHA256_DIGEST_SIZE); 147905ab2901SDag-Erling Smørgrav res = _digest_nettle(SHA256_DIGEST_SIZE, (unsigned char*)sldns_buffer_begin(buf), 148005ab2901SDag-Erling Smørgrav (unsigned int)sldns_buffer_limit(buf), (unsigned char*)digest); 148105ab2901SDag-Erling Smørgrav res &= nettle_ecc_point_set(&pubkey, x, y); 148205ab2901SDag-Erling Smørgrav res &= nettle_ecdsa_verify (&pubkey, SHA256_DIGEST_SIZE, digest, &signature); 148305ab2901SDag-Erling Smørgrav mpz_clear(x); 148405ab2901SDag-Erling Smørgrav mpz_clear(y); 148505ab2901SDag-Erling Smørgrav break; 148605ab2901SDag-Erling Smørgrav } 148705ab2901SDag-Erling Smørgrav case SHA384_DIGEST_SIZE: 148805ab2901SDag-Erling Smørgrav { 148905ab2901SDag-Erling Smørgrav uint8_t digest[SHA384_DIGEST_SIZE]; 149005ab2901SDag-Erling Smørgrav mpz_t x, y; 149105ab2901SDag-Erling Smørgrav nettle_ecc_point_init(&pubkey, &nettle_secp_384r1); 149205ab2901SDag-Erling Smørgrav nettle_mpz_init_set_str_256_u(x, SHA384_DIGEST_SIZE, key); 149305ab2901SDag-Erling Smørgrav nettle_mpz_init_set_str_256_u(y, SHA384_DIGEST_SIZE, key+SHA384_DIGEST_SIZE); 149405ab2901SDag-Erling Smørgrav nettle_mpz_set_str_256_u(signature.r, SHA384_DIGEST_SIZE, sigblock); 149505ab2901SDag-Erling Smørgrav nettle_mpz_set_str_256_u(signature.s, SHA384_DIGEST_SIZE, sigblock+SHA384_DIGEST_SIZE); 149605ab2901SDag-Erling Smørgrav res = _digest_nettle(SHA384_DIGEST_SIZE, (unsigned char*)sldns_buffer_begin(buf), 149705ab2901SDag-Erling Smørgrav (unsigned int)sldns_buffer_limit(buf), (unsigned char*)digest); 149805ab2901SDag-Erling Smørgrav res &= nettle_ecc_point_set(&pubkey, x, y); 149905ab2901SDag-Erling Smørgrav res &= nettle_ecdsa_verify (&pubkey, SHA384_DIGEST_SIZE, digest, &signature); 150005ab2901SDag-Erling Smørgrav mpz_clear(x); 150105ab2901SDag-Erling Smørgrav mpz_clear(y); 150205ab2901SDag-Erling Smørgrav nettle_ecc_point_clear(&pubkey); 150305ab2901SDag-Erling Smørgrav break; 150405ab2901SDag-Erling Smørgrav } 150505ab2901SDag-Erling Smørgrav default: 150605ab2901SDag-Erling Smørgrav return "unknown ECDSA algorithm"; 150705ab2901SDag-Erling Smørgrav } 150805ab2901SDag-Erling Smørgrav 150905ab2901SDag-Erling Smørgrav /* Clear and return */ 151005ab2901SDag-Erling Smørgrav nettle_dsa_signature_clear(&signature); 151105ab2901SDag-Erling Smørgrav if (!res) 151205ab2901SDag-Erling Smørgrav return "ECDSA signature verification failed"; 151305ab2901SDag-Erling Smørgrav else 151405ab2901SDag-Erling Smørgrav return NULL; 151505ab2901SDag-Erling Smørgrav } 151605ab2901SDag-Erling Smørgrav #endif 151705ab2901SDag-Erling Smørgrav 151805ab2901SDag-Erling Smørgrav /** 151905ab2901SDag-Erling Smørgrav * Check a canonical sig+rrset and signature against a dnskey 152005ab2901SDag-Erling Smørgrav * @param buf: buffer with data to verify, the first rrsig part and the 152105ab2901SDag-Erling Smørgrav * canonicalized rrset. 152205ab2901SDag-Erling Smørgrav * @param algo: DNSKEY algorithm. 152305ab2901SDag-Erling Smørgrav * @param sigblock: signature rdata field from RRSIG 152405ab2901SDag-Erling Smørgrav * @param sigblock_len: length of sigblock data. 152505ab2901SDag-Erling Smørgrav * @param key: public key data from DNSKEY RR. 152605ab2901SDag-Erling Smørgrav * @param keylen: length of keydata. 152705ab2901SDag-Erling Smørgrav * @param reason: bogus reason in more detail. 152805ab2901SDag-Erling Smørgrav * @return secure if verification succeeded, bogus on crypto failure, 152905ab2901SDag-Erling Smørgrav * unchecked on format errors and alloc failures. 153005ab2901SDag-Erling Smørgrav */ 153105ab2901SDag-Erling Smørgrav enum sec_status 153205ab2901SDag-Erling Smørgrav verify_canonrrset(sldns_buffer* buf, int algo, unsigned char* sigblock, 153305ab2901SDag-Erling Smørgrav unsigned int sigblock_len, unsigned char* key, unsigned int keylen, 153405ab2901SDag-Erling Smørgrav char** reason) 153505ab2901SDag-Erling Smørgrav { 153605ab2901SDag-Erling Smørgrav unsigned int digest_size = 0; 153705ab2901SDag-Erling Smørgrav 153805ab2901SDag-Erling Smørgrav if (sigblock_len == 0 || keylen == 0) { 153905ab2901SDag-Erling Smørgrav *reason = "null signature"; 154005ab2901SDag-Erling Smørgrav return sec_status_bogus; 154105ab2901SDag-Erling Smørgrav } 154205ab2901SDag-Erling Smørgrav 154305ab2901SDag-Erling Smørgrav switch(algo) { 154405ab2901SDag-Erling Smørgrav case LDNS_DSA: 154505ab2901SDag-Erling Smørgrav case LDNS_DSA_NSEC3: 154605ab2901SDag-Erling Smørgrav *reason = _verify_nettle_dsa(buf, sigblock, sigblock_len, key, keylen); 154705ab2901SDag-Erling Smørgrav if (*reason != NULL) 154805ab2901SDag-Erling Smørgrav return sec_status_bogus; 154905ab2901SDag-Erling Smørgrav else 155005ab2901SDag-Erling Smørgrav return sec_status_secure; 155105ab2901SDag-Erling Smørgrav 155205ab2901SDag-Erling Smørgrav case LDNS_RSASHA1: 155305ab2901SDag-Erling Smørgrav case LDNS_RSASHA1_NSEC3: 155405ab2901SDag-Erling Smørgrav digest_size = (digest_size ? digest_size : SHA1_DIGEST_SIZE); 155505ab2901SDag-Erling Smørgrav #ifdef USE_SHA2 155605ab2901SDag-Erling Smørgrav case LDNS_RSASHA256: 155705ab2901SDag-Erling Smørgrav digest_size = (digest_size ? digest_size : SHA256_DIGEST_SIZE); 155805ab2901SDag-Erling Smørgrav case LDNS_RSASHA512: 155905ab2901SDag-Erling Smørgrav digest_size = (digest_size ? digest_size : SHA512_DIGEST_SIZE); 156005ab2901SDag-Erling Smørgrav 156105ab2901SDag-Erling Smørgrav #endif 156205ab2901SDag-Erling Smørgrav *reason = _verify_nettle_rsa(buf, digest_size, (char*)sigblock, 156305ab2901SDag-Erling Smørgrav sigblock_len, key, keylen); 156405ab2901SDag-Erling Smørgrav if (*reason != NULL) 156505ab2901SDag-Erling Smørgrav return sec_status_bogus; 156605ab2901SDag-Erling Smørgrav else 156705ab2901SDag-Erling Smørgrav return sec_status_secure; 156805ab2901SDag-Erling Smørgrav 156905ab2901SDag-Erling Smørgrav #ifdef USE_ECDSA 157005ab2901SDag-Erling Smørgrav case LDNS_ECDSAP256SHA256: 157105ab2901SDag-Erling Smørgrav digest_size = (digest_size ? digest_size : SHA256_DIGEST_SIZE); 157205ab2901SDag-Erling Smørgrav case LDNS_ECDSAP384SHA384: 157305ab2901SDag-Erling Smørgrav digest_size = (digest_size ? digest_size : SHA384_DIGEST_SIZE); 157405ab2901SDag-Erling Smørgrav *reason = _verify_nettle_ecdsa(buf, digest_size, sigblock, 157505ab2901SDag-Erling Smørgrav sigblock_len, key, keylen); 157605ab2901SDag-Erling Smørgrav if (*reason != NULL) 157705ab2901SDag-Erling Smørgrav return sec_status_bogus; 157805ab2901SDag-Erling Smørgrav else 157905ab2901SDag-Erling Smørgrav return sec_status_secure; 158005ab2901SDag-Erling Smørgrav #endif 158105ab2901SDag-Erling Smørgrav case LDNS_RSAMD5: 158205ab2901SDag-Erling Smørgrav case LDNS_ECC_GOST: 158305ab2901SDag-Erling Smørgrav default: 158405ab2901SDag-Erling Smørgrav *reason = "unable to verify signature, unknown algorithm"; 158505ab2901SDag-Erling Smørgrav return sec_status_bogus; 158605ab2901SDag-Erling Smørgrav } 158705ab2901SDag-Erling Smørgrav } 158805ab2901SDag-Erling Smørgrav 158905ab2901SDag-Erling Smørgrav #endif /* HAVE_SSL or HAVE_NSS or HAVE_NETTLE */ 1590