introduced extension hooks framework

4 files changed, 35 insertions, 13 deletions

diff --git a/lib/Makefile.am b/lib/Makefile.am
index 6f3f9f3..69c749e 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -1,24 +1,25 @@
 lib_LTLIBRARIES = libopkele.la
 
 INCLUDES = \
 	   -I${top_srcdir}/include/ \
 	   ${KONFORKA_CFLAGS} \
 	   ${OPENSSL_CFLAGS} \
 	   ${MIMETIC_CFLAGS} \
 	   ${LIBCURL_CPPFLAGS} \
 	   ${PCREPP_CFLAGS}
 LDADD = \
 	${LIBCURL} \
 	${PCREPP_LIBS} \
 	${MIMETIC_LIBS} \
 	${OPENSSL_LIBS} \
 	${KONFORKA_LIBS}
 
 libopkele_la_SOURCES = \
 		       params.cc \
 		       util.cc \
 		       server.cc \
 		       secret.cc \
 		       data.cc \
 		       consumer.cc \
-		       exception.cc
+		       exception.cc \
+		       extension.cc
diff --git a/lib/consumer.cc b/lib/consumer.cc
index bb6358c..10c2fa0 100644
--- a/lib/consumer.cc
+++ b/lib/consumer.cc
@@ -94,160 +94,164 @@ namespace opkele {
 	if(p.has_param("assoc_type") && p.get_param("assoc_type")!="HMAC-SHA1")
 	    throw bad_input(OPKELE_CP_ "unsupported assoc_type");
 	string st;
 	if(p.has_param("session_type")) st = p.get_param("session_type");
 	if((!st.empty()) && st!="DH-SHA1")
 	    throw bad_input(OPKELE_CP_ "unsupported session_type");
 	secret_t secret;
 	if(st.empty()) {
 	    secret.from_base64(p.get_param("mac_key"));
 	}else{
 	    util::bignum_t s_pub = util::base64_to_bignum(p.get_param("dh_server_public"));
 	    vector<unsigned char> ck(DH_size(dh));
 	    int cklen = DH_compute_key(&(ck.front()),s_pub,dh);
 	    if(cklen<0)
 		throw exception_openssl(OPKELE_CP_ "failed to DH_compute_key()");
 	    ck.resize(cklen);
 	    // OpenID algorithm requires extra zero in case of set bit here
 	    if(ck[0]&0x80) ck.insert(ck.begin(),1,0);
 	    unsigned char key_sha1[SHA_DIGEST_LENGTH];
 	    SHA1(&(ck.front()),ck.size(),key_sha1);
 	    secret.enxor_from_base64(key_sha1,p.get_param("enc_mac_key"));
 	}
 	int expires_in = 0;
 	if(p.has_param("expires_in")) {
 	    expires_in = util::string_to_long(p.get_param("expires_in"));
 	}else if(p.has_param("issued") && p.has_param("expiry")) {
 	    expires_in = util::w3c_to_time(p.get_param("expiry"))-util::w3c_to_time(p.get_param("issued"));
 	}else
 	    throw bad_input(OPKELE_CP_ "no expiration information");
 	return store_assoc(server,p.get_param("assoc_handle"),secret,expires_in);
     }
 
-    string consumer_t::checkid_immediate(const string& identity,const string& return_to,const string& trust_root) {
-	return checkid_(mode_checkid_immediate,identity,return_to,trust_root);
+    string consumer_t::checkid_immediate(const string& identity,const string& return_to,const string& trust_root,extension_t *ext) {
+	return checkid_(mode_checkid_immediate,identity,return_to,trust_root,ext);
     }
-    string consumer_t::checkid_setup(const string& identity,const string& return_to,const string& trust_root) {
-	return checkid_(mode_checkid_setup,identity,return_to,trust_root);
+    string consumer_t::checkid_setup(const string& identity,const string& return_to,const string& trust_root,extension_t *ext) {
+	return checkid_(mode_checkid_setup,identity,return_to,trust_root,ext);
     }
-    string consumer_t::checkid_(mode_t mode,const string& identity,const string& return_to,const string& trust_root) {
+    string consumer_t::checkid_(mode_t mode,const string& identity,const string& return_to,const string& trust_root,extension_t *ext) {
 	params_t p;
 	if(mode==mode_checkid_immediate)
 	    p["mode"]="checkid_immediate";
 	else if(mode==mode_checkid_setup)
 	    p["mode"]="checkid_setup";
 	else
 	    throw bad_input(OPKELE_CP_ "unknown checkid_* mode");
 	string iurl = canonicalize(identity);
 	string server, delegate;
 	retrieve_links(iurl,server,delegate);
 	p["identity"] = delegate.empty()?iurl:delegate;
 	if(!trust_root.empty())
 	    p["trust_root"] = trust_root;
 	p["return_to"] = return_to;
 	try {
 	    try {
 		string ah = find_assoc(server)->handle();
 		p["assoc_handle"] = ah;
 	    }catch(failed_lookup& fl) {
 		string ah = associate(server)->handle();
 		p["assoc_handle"] = ah;
 	    }
 	}catch(exception& e) { }
+	if(ext) ext->checkid_hook(p,identity);
 	return p.append_query(server);
     }
 
-    void consumer_t::id_res(const params_t& pin,const string& identity) {
+    void consumer_t::id_res(const params_t& pin,const string& identity,extension_t *ext) {
 	if(pin.has_param("openid.user_setup_url"))
 	    throw id_res_setup(OPKELE_CP_ "assertion failed, setup url provided",pin.get_param("openid.user_setup_url"));
 	string server,delegate;
 	retrieve_links(identity.empty()?pin.get_param("openid.identity"):canonicalize(identity),server,delegate);
+	params_t ps;
 	try {
 	    assoc_t assoc = retrieve_assoc(server,pin.get_param("openid.assoc_handle"));
 	    const string& sigenc = pin.get_param("openid.sig");
 	    mimetic::Base64::Decoder b;
 	    vector<unsigned char> sig;
 	    mimetic::decode(
 		    sigenc.begin(),sigenc.end(), b,
 		    back_insert_iterator<vector<unsigned char> >(sig) );
 	    const string& slist = pin.get_param("openid.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 += ':';
 		f.insert(0,"openid.");
 		kv += pin.get_param(f);
 		kv += '\n';
+		if(ext) ps[f.substr(sizeof("openid."))] = pin.get_param(f);
 		if(co==string::npos)
 		    break;
 		p = co+1;
 	    }
 	    secret_t secret = assoc->secret();
 	    unsigned int md_len = 0;
 	    unsigned char *md = HMAC(
 		    EVP_sha1(),
 		    &(secret.front()),secret.size(),
 		    (const unsigned char *)kv.data(),kv.length(),
 		    0,&md_len);
 	    if(sig.size()!=md_len || memcmp(&(sig.front()),md,md_len))
 		throw id_res_mismatch(OPKELE_CP_ "signature mismatch");
 	}catch(failed_lookup& e) { /* XXX: more specific? */
 	    const string& slist = pin.get_param("openid.signed");
 	    string::size_type pp = 0;
 	    params_t p;
 	    while(true) {
 		string::size_type co = slist.find(',',pp);
 		string f = "openid.";
 		f += (co==string::npos)?slist.substr(pp):slist.substr(pp,co-pp);
 		p[f] = pin.get_param(f);
 		if(co==string::npos)
 		    break;
 		pp = co+1;
 	    }
 	    p["openid.assoc_handle"] = pin.get_param("openid.assoc_handle");
 	    p["openid.sig"] = pin.get_param("openid.sig");
 	    p["openid.signed"] = pin.get_param("openid.signed");
 	    try {
 		string ih = pin.get_param("openid.invalidate_handle");
 		p["openid.invalidate_handle"] = ih;
 	    }catch(failed_lookup& fl) { }
 	    try {
 		check_authentication(server,p);
 	    }catch(failed_check_authentication& fca) {
 		throw id_res_failed(OPKELE_CP_ "failed to check_authentication()");
 	    }
 	}
+	if(ext) ext->id_res_hook(pin,ps,identity);
     }
 
     void consumer_t::check_authentication(const string& server,const params_t& p) {
 	string request = "openid.mode=check_authentication";
 	for(params_t::const_iterator i=p.begin();i!=p.end();++i) {
 	    if(i->first!="openid.mode") {
 		request += '&';
 		request += i->first;
 		request += '=';
 		request += util::url_encode(i->second);
 	    }
 	}
 	curl_t curl = curl_easy_init();
 	if(!curl)
 	    throw exception_curl(OPKELE_CP_ "failed to curl_easy_init()");
 	string response;
 	CURLcode r;
 	(r=curl_misc_sets(curl))
 	|| (r=curl_easy_setopt(curl,CURLOPT_URL,server.c_str()))
 	|| (r=curl_easy_setopt(curl,CURLOPT_POST,1))
 	|| (r=curl_easy_setopt(curl,CURLOPT_POSTFIELDS,request.data()))
 	|| (r=curl_easy_setopt(curl,CURLOPT_POSTFIELDSIZE,request.length()))
 	|| (r=curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,_curl_tostring))
 	|| (r=curl_easy_setopt(curl,CURLOPT_WRITEDATA,&response))
 	;
 	if(r)
 	    throw exception_curl(OPKELE_CP_ "failed to curl_easy_setopt()",r);
 	if(r=curl_easy_perform(curl))
 	    throw exception_curl(OPKELE_CP_ "failed to curl_easy_perform()",r);
 	params_t pp; pp.parse_keyvalues(response);
 	if(pp.has_param("invalidate_handle"))
 	    invalidate_assoc(server,pp.get_param("invalidate_handle"));
diff --git a/lib/extension.cc b/lib/extension.cc
new file mode 100644
index 0000000..bd2195d
--- a/dev/null
+++ b/lib/extension.cc
@@ -0,0 +1,15 @@
+#include <opkele/exception.h>
+#include <opkele/extension.h>
+
+namespace opkele {
+
+    void extension_t::checkid_hook(params_t& p,const string& identity) {
+	throw not_implemented(OPKELE_CP_ "Consumer checkid_hook not implemented");
+    }
+    void id_res_hook(const params_t& p,const params_t& sp,const string& identity) {
+	throw not_implemented(OPKELE_CP_ "Consumer id_res_hook not implemented");
+    }
+    void checkid_hook(const params_t& pin,params_t& pout) {
+	throw not_implemented(OPKELE_CP_ "Server checkid_hook not implemented");
+    }
+}
diff --git a/lib/server.cc b/lib/server.cc
index 5eee1f3..8c29abb 100644
--- a/lib/server.cc
+++ b/lib/server.cc
@@ -38,104 +38,106 @@ namespace opkele {
 	    vector<unsigned char> ck(DH_size(dh));
 	    int cklen = DH_compute_key(&(ck.front()),c_pub,dh);
 	    if(cklen<0)
 		throw exception_openssl(OPKELE_CP_ "failed to DH_compute_key()");
 	    ck.resize(cklen);
 	    // OpenID algorithm requires extra zero in case of set bit here
 	    if(ck[0]&0x80) ck.insert(ck.begin(),1,0);
 	    SHA1(&(ck.front()),ck.size(),key_sha1);
 	    st = sess_dh_sha1;
 	}
 	assoc_t assoc = alloc_assoc(mode_associate);
 	time_t now = time(0);
 	pout.clear();
 	pout["assoc_type"] = assoc->assoc_type();
 	pout["assoc_handle"] = assoc->handle();
 	/* TODO: eventually remove deprecated stuff */
 	pout["issued"] = util::time_to_w3c(now);
 	pout["expiry"] = util::time_to_w3c(now+assoc->expires_in());
 	pout["expires_in"] = util::long_to_string(assoc->expires_in());
 	secret_t secret = assoc->secret();
 	switch(st) {
 	    case sess_dh_sha1:
 		pout["session_type"] = "DH-SHA1";
 		pout["dh_server_public"] = util::bignum_to_base64(dh->pub_key);
 		secret.enxor_to_base64(key_sha1,pout["enc_mac_key"]);
 		break;
 	    default:
 		secret.to_base64(pout["mac_key"]);
 		break;
 	}
     }
 
-    void server_t::checkid_immediate(const params_t& pin,string& return_to,params_t& pout) {
-	checkid_(mode_checkid_immediate,pin,return_to,pout);
+    void server_t::checkid_immediate(const params_t& pin,string& return_to,params_t& pout,extension_t *ext) {
+	checkid_(mode_checkid_immediate,pin,return_to,pout,ext);
     }
 
-    void server_t::checkid_setup(const params_t& pin,string& return_to,params_t& pout) {
-	checkid_(mode_checkid_setup,pin,return_to,pout);
+    void server_t::checkid_setup(const params_t& pin,string& return_to,params_t& pout,extension_t *ext) {
+	checkid_(mode_checkid_setup,pin,return_to,pout,ext);
     }
 
-    void server_t::checkid_(mode_t mode,const params_t& pin,string& return_to,params_t& pout) {
+    void server_t::checkid_(mode_t mode,const params_t& pin,string& return_to,params_t& pout,extension_t *ext) {
 	if(mode!=mode_checkid_immediate && mode!=mode_checkid_setup)
 	    throw bad_input(OPKELE_CP_ "invalid checkid_* mode");
 	pout.clear();
 	assoc_t assoc;
 	try {
 	    assoc = retrieve_assoc(pin.get_param("openid.assoc_handle"));
 	}catch(failed_lookup& fl) {
 	    // no handle specified or no valid handle found, going dumb
 	    assoc = alloc_assoc(mode_checkid_setup);
 	    if(pin.has_param("openid.assoc_handle"))
 		pout["invalidate_handle"]=pin.get_param("openid.assoc_handle");
 	}
 	string trust_root;
 	try {
 	    trust_root = pin.get_param("openid.trust_root");
 	}catch(failed_lookup& fl) { }
 	string identity = pin.get_param("openid.identity");
 	return_to = pin.get_param("openid.return_to");
 	validate(*assoc,pin,identity,trust_root);
 	pout["mode"] = "id_res";
 	pout["assoc_handle"] = assoc->handle();
 	if(pin.has_param("openid.assoc_handle") && assoc->stateless())
 	    pout["invalidate_handle"] = pin.get_param("openid.assoc_handle");
 	pout["identity"] = identity;
 	pout["return_to"] = return_to;
 	/* TODO: eventually remove deprecated stuff */
 	time_t now = time(0);
 	pout["issued"] = util::time_to_w3c(now);
 	pout["valid_to"] = util::time_to_w3c(now+120);
 	pout["exipres_in"] = "120";
-	pout.sign(assoc->secret(),pout["sig"],pout["signed"]="mode,identity,return_to");
+	pout["signed"]="mode,identity,return_to";
+	if(ext) ext->checkid_hook(pin,pout);
+	pout.sign(assoc->secret(),pout["sig"],pout["signed"]);
     }
 
     void server_t::check_authentication(const params_t& pin,params_t& pout) {
 	vector<unsigned char>  sig;
 	mimetic::Base64::Decoder b;
 	const string& sigenc = pin.get_param("openid.sig");
 	mimetic::decode(
 		sigenc.begin(),sigenc.end(), b,
 		back_insert_iterator<vector<unsigned char> >(sig));
 	assoc_t assoc;
 	try {
 	    assoc = retrieve_assoc(pin.get_param("openid.assoc_handle"));
 	}catch(failed_lookup& fl) {
 	    throw failed_assertion(OPKELE_CP_ "invalid handle or handle not specified");
 	}
 	if(!assoc->stateless())
 	    throw stateful_handle(OPKELE_CP_ "will not do check_authentication on a stateful handle");
 	const string& slist = pin.get_param("openid.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 += ':';
 	    if(f=="mode")
 		kv += "id_res";
 	    else {
 		f.insert(0,"openid.");
 		kv += pin.get_param(f);
 	    }
 	    kv += '\n';