use local array for hmac when calculating signature

Signed-off-by: Michael Krelin <hacker@klever.net>

1 files changed, 7 insertions, 4 deletions

diff --git a/lib/util.cc b/lib/util.cc
index b85a377..bb8a2e8 100644
--- a/lib/util.cc
+++ b/lib/util.cc
@@ -1,142 +1,144 @@
 #include <errno.h>
 #include <cassert>
 #include <cctype>
 #include <cstring>
 #include <vector>
 #include <string>
 #include <stack>
 #include <algorithm>
 #include <openssl/bio.h>
 #include <openssl/evp.h>
+#include <openssl/sha.h>
 #include <openssl/hmac.h>
 #include <curl/curl.h>
-#include "opkele/util.h"
-#include "opkele/exception.h"
+#include <opkele/util.h>
+#include <opkele/exception.h>
+#include <opkele/debug.h>
 
 #include <config.h>
 #ifdef HAVE_DEMANGLE
 # include <cxxabi.h>
 #endif
 
 namespace opkele {
     using namespace std;
 
     namespace util {
 
 	/*
 	 * base64
 	 */
 	string encode_base64(const void *data,size_t length) {
 	    BIO *b64 = 0, *bmem = 0;
 	    try {
 		b64 = BIO_new(BIO_f_base64());
 		if(!b64)
 		    throw exception_openssl(OPKELE_CP_ "failed to BIO_new() base64 encoder");
 		BIO_set_flags(b64,BIO_FLAGS_BASE64_NO_NL);
 		bmem = BIO_new(BIO_s_mem());
 		BIO_set_flags(b64,BIO_CLOSE);
 		if(!bmem)
 		    throw exception_openssl(OPKELE_CP_ "failed to BIO_new() memory buffer");
 		BIO_push(b64,bmem);
 		if(((size_t)BIO_write(b64,data,length))!=length)
 		    throw exception_openssl(OPKELE_CP_ "failed to BIO_write()");
 		if(BIO_flush(b64)!=1)
 		    throw exception_openssl(OPKELE_CP_ "failed to BIO_flush()");
 		char *rvd;
 		long rvl = BIO_get_mem_data(bmem,&rvd);
 		string rv(rvd,rvl);
 		BIO_free_all(b64);
 		return rv;
 	    }catch(...) {
 		if(b64) BIO_free_all(b64);
 		throw;
 	    }
 	}
 
 	void decode_base64(const string& data,vector<unsigned char>& rv) {
 	    BIO *b64 = 0, *bmem = 0;
 	    rv.clear();
 	    try {
 		bmem = BIO_new_mem_buf((void*)data.data(),data.size());
 		if(!bmem)
 		    throw exception_openssl(OPKELE_CP_ "failed to BIO_new_mem_buf()");
 		b64 = BIO_new(BIO_f_base64());
 		if(!b64)
 		    throw exception_openssl(OPKELE_CP_ "failed to BIO_new() base64 decoder");
 		BIO_set_flags(b64,BIO_FLAGS_BASE64_NO_NL);
 		BIO_push(b64,bmem);
 		unsigned char tmp[512];
 		size_t rb = 0;
 		while((rb=BIO_read(b64,tmp,sizeof(tmp)))>0)
 		    rv.insert(rv.end(),tmp,&tmp[rb]);
 		BIO_free_all(b64);
 	    }catch(...) {
 		if(b64) BIO_free_all(b64);
 		throw;
 	    }
 	}
 
 	/*
 	 * big numerics
 	 */
 
 	BIGNUM *base64_to_bignum(const string& b64) {
 	    vector<unsigned char> bin;
 	    decode_base64(b64,bin);
 	    BIGNUM *rv = BN_bin2bn(&(bin.front()),bin.size(),0);
 	    if(!rv)
 		throw failed_conversion(OPKELE_CP_ "failed to BN_bin2bn()");
 	    return rv;
 	}
 
 	BIGNUM *dec_to_bignum(const string& dec) {
 	    BIGNUM *rv = 0;
 	    if(!BN_dec2bn(&rv,dec.c_str()))
 		throw failed_conversion(OPKELE_CP_ "failed to BN_dec2bn()");
 	    return rv;
 	}
 
 	string bignum_to_base64(const BIGNUM *bn) {
 	    vector<unsigned char> bin(BN_num_bytes(bn)+1);
 	    unsigned char *binptr = &(bin.front())+1;
 	    int l = BN_bn2bin(bn,binptr);
 	    if(l && (*binptr)&0x80){
 		(*(--binptr)) = 0; ++l;
 	    }
 	    return encode_base64(binptr,l);
 	}
 
 	/*
 	 * w3c times
 	 */
 
 	string time_to_w3c(time_t t) {
 	    struct tm tm_t;
 	    if(!gmtime_r(&t,&tm_t))
 		throw failed_conversion(OPKELE_CP_ "failed to BN_dec2bn()");
 	    char rv[25];
 	    if(!strftime(rv,sizeof(rv)-1,"%Y-%m-%dT%H:%M:%SZ",&tm_t))
 		throw failed_conversion(OPKELE_CP_ "failed to strftime()");
 	    return rv;
 	}
 
 	time_t w3c_to_time(const string& w) {
 	    int fraction;
 	    struct tm tm_t;
 	    memset(&tm_t,0,sizeof(tm_t));
 	    if( (
 			sscanf(
 			    w.c_str(),
 			    "%04d-%02d-%02dT%02d:%02d:%02dZ",
 			    &tm_t.tm_year,&tm_t.tm_mon,&tm_t.tm_mday,
 			    &tm_t.tm_hour,&tm_t.tm_min,&tm_t.tm_sec
 			    ) != 6
 		) && (
 		    sscanf(
 			w.c_str(),
 			"%04d-%02d-%02dT%02d:%02d:%02d.%03dZ",
 			&tm_t.tm_year,&tm_t.tm_mon,&tm_t.tm_mday,
 			&tm_t.tm_hour,&tm_t.tm_min,&tm_t.tm_sec,
 			&fraction
 			) != 7
 		    ) )
@@ -295,138 +297,139 @@ namespace opkele {
 		     else{
 			 pseg += '%';
 			 pseg += toupper(tmp[0]); pseg += toupper(tmp[1]);
 		     }
 		 }else if(qf) {
 		     rv += pseg; rv += c;
 		     pseg.clear();
 		 }else if(n>=ul || strchr("?/#",c)) {
 		     if(pseg.empty() || pseg==".") {
 		     }else if(pseg=="..") {
 			 if(psegs.size()>1) {
 			     rv.resize(psegs.top()); psegs.pop();
 			 }
 		     }else{
 			 psegs.push(rv.length());
 			 if(c!='/') {
 			     pseg += c;
 			     qf = true;
 			 }
 			 rv += '/'; rv += pseg;
 		     }
 		     if(c=='/' && (n>=ul || strchr("?#",uri[n])) ) {
 			 rv += '/';
 			 if(n<ul)
 			     qf = true;
 		     }else if(strchr("?#",c)) {
 			 if(psegs.size()==1 && psegs.top()==rv.length())
 			     rv += '/';
 			 if(pseg.empty())
 			     rv += c;
 			 qf = true;
 		     }
 		     pseg.clear();
 		 }else{
 		     pseg += c;
 		 }
 	     }
 	     if(!pseg.empty()) {
 		 if(!qf) rv += '/';
 		 rv += pseg;
 	     }
 	     return rv;
 	 }
 
 	string& strip_uri_fragment_part(string& u) {
 	    string::size_type q = u.find('?'), f = u.find('#');
 	    if(q==string::npos) {
 		if(f!=string::npos)
 		    u.erase(f);
 	    }else{
 		if(f!=string::npos) {
 		    if(f<q)
 			u.erase(f,q-f);
 		    else
 			u.erase(f);
 		}
 	    }
 	    return u;
 	}
 
 	bool uri_matches_realm(const string& uri,const string& realm) {
 	    string nrealm = opkele::util::rfc_3986_normalize_uri(realm);
 	    string nu = opkele::util::rfc_3986_normalize_uri(uri);
 	    string::size_type pr = nrealm.find("://");
 	    string::size_type pu = nu.find("://");
 	    assert(!(pr==string::npos || pu==string::npos));
 	    pr += sizeof("://")-1;
 	    pu += sizeof("://")-1;
 	    if(!strncmp(nrealm.c_str()+pr,"*.",2)) {
 		pr = nrealm.find('.',pr);
 		pu = nu.find('.',pu);
 		assert(pr!=string::npos);
 		if(pu==string::npos)
 		    return false;
 		// TODO: check for overgeneralized realm
 	    }
 	    string::size_type lr = nrealm.length();
 	    string::size_type lu = nu.length();
 	    if( (lu-pu) < (lr-pr) )
 		return false;
 	    pair<const char*,const char*> mp = mismatch(
 		    nrealm.c_str()+pr,nrealm.c_str()+lr,
 		    nu.c_str()+pu);
 	    if( (*(mp.first-1))!='/'
 		    && !strchr("/?#",*mp.second) )
 		return false;
 	    return true;
 	}
 
 	string abi_demangle(const char *mn) {
 #ifndef HAVE_DEMANGLE
 	    return mn;
 #else /* !HAVE_DEMANGLE */
 	    int dstat;
 	    char *demangled = abi::__cxa_demangle(mn,0,0,&dstat);
 	    if(dstat)
 		return mn;
 	    string rv = demangled;
 	    free(demangled);
 	    return rv;
 #endif /* !HAVE_DEMANGLE */
 	}
 
 	string base64_signature(const assoc_t& assoc,const basic_openid_message& om) {
 	    const string& slist = om.get_field("signed");
 	    string kv;
 	    string::size_type p=0;
 	    while(true) {
 		string::size_type co = slist.find(',',p);
 		string f = (co==string::npos)
 		    ?slist.substr(p):slist.substr(p,co-p);
 		kv += f;
 		kv += ':';
 		kv += om.get_field(f);
 		kv += '\n';
 		if(co==string::npos) break;
 		p = co+1;
 	    }
 	    const secret_t& secret = assoc->secret();
 	    const EVP_MD *evpmd;
 	    const string& at = assoc->assoc_type();
 	    if(at=="HMAC-SHA256")
 		evpmd = EVP_sha256();
 	    else if(at=="HMAC-SHA1")
 		evpmd = EVP_sha1();
 	    else
 		throw unsupported(OPKELE_CP_ "unknown association type");
 	    unsigned int md_len = 0;
-	    unsigned char *md = HMAC(evpmd,
+	    unsigned char md[SHA256_DIGEST_LENGTH];
+	    HMAC(evpmd,
 		    &(secret.front()),secret.size(),
 		    (const unsigned char*)kv.data(),kv.length(),
-		    0,&md_len);
+		    md,&md_len);
 	    return encode_base64(md,md_len);
 	}
 
     }
 
 }