OnModuleRehash(NULL,"ssl");
Implementation eventlist[] = { I_OnRawSocketConnect, I_OnRawSocketAccept,
I_OnRawSocketClose, I_OnRawSocketRead, I_OnRawSocketWrite, I_OnCleanup, I_On005Numeric,
- I_OnBufferFlushed, I_OnRequest, I_OnSyncUserMetaData, I_OnDecodeMetaData,
- I_OnUnloadModule, I_OnRehash, I_OnModuleRehash, I_OnWhois, I_OnPostConnect,
- I_OnHookUserIO };
- ServerInstance->Modules->Attach(eventlist, this, 17);
+ I_OnBufferFlushed, I_OnRequest, I_OnUnloadModule, I_OnRehash, I_OnModuleRehash,
+ I_OnPostConnect, I_OnHookIO };
+ ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation));
}
- virtual void OnHookUserIO(User* user, const std::string &targetip)
+ virtual void OnHookIO(EventHandler* user, ListenSocketBase* lsb)
{
- if (!user->GetIOHook() && isin(targetip,user->GetPort(), listenports))
+ if (!user->GetIOHook() && isin(lsb->GetIP(),lsb->GetPort(),listenports))
{
/* Hook the user with our module */
user->AddIOHook(this);
{
listenports.push_back(addr + ":" + ConvToStr(portno));
- for (size_t i = 0; i < ServerInstance->Config->ports.size(); i++)
- if ((ServerInstance->Config->ports[i]->GetPort() == portno) && (ServerInstance->Config->ports[i]->GetIP() == addr))
- ServerInstance->Config->ports[i]->SetDescription("ssl");
+ for (size_t i = 0; i < ServerInstance->ports.size(); i++)
+ if ((ServerInstance->ports[i]->GetPort() == portno) && (ServerInstance->ports[i]->GetIP() == addr))
+ ServerInstance->ports[i]->SetDescription("ssl");
ServerInstance->Logs->Log("m_ssl_openssl",DEFAULT, "m_ssl_openssl.so: Enabling SSL for port %ld", portno);
- sslports.append((addr.empty() ? "*" : addr)).append(":").append(ConvToStr(portno)).append(";");
+ if (addr != "127.0.0.1")
+ sslports.append((addr.empty() ? "*" : addr)).append(":").append(ConvToStr(portno)).append(";");
}
catch (ModuleException &e)
{
{
for(unsigned int i = 0; i < listenports.size(); i++)
{
- for (size_t j = 0; j < ServerInstance->Config->ports.size(); j++)
- if (listenports[i] == (ServerInstance->Config->ports[j]->GetIP()+":"+ConvToStr(ServerInstance->Config->ports[j]->GetPort())))
- ServerInstance->Config->ports[j]->SetDescription("plaintext");
+ for (size_t j = 0; j < ServerInstance->ports.size(); j++)
+ if (listenports[i] == (ServerInstance->ports[j]->GetIP()+":"+ConvToStr(ServerInstance->ports[j]->GetPort())))
+ ServerInstance->ports[j]->SetDescription("plaintext");
}
}
}
return "OK";
}
}
+ else if (strcmp("GET_FP", request->GetId()) == 0)
+ {
+ if (ISR->Sock->GetFd() > -1)
+ {
+ issl_session* session = &sessions[ISR->Sock->GetFd()];
+ if (session->sess)
+ {
+ Extensible* ext = ISR->Sock;
+ ssl_cert* certinfo;
+ if (ext->GetExt("ssl_cert",certinfo))
+ return certinfo->GetFingerprint().c_str();
+ }
+ }
+ }
return NULL;
}
- virtual void OnRawSocketAccept(int fd, const std::string &ip, int localport)
+ virtual void OnRawSocketAccept(int fd, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server)
{
/* Are there any possibilities of an out of range fd? Hope not, but lets be paranoid */
if ((fd < 0) || (fd > ServerInstance->SE->GetMaxFds() - 1))
}
}
- // :kenny.chatspike.net 320 Om Epy|AFK :is a Secure Connection
- virtual void OnWhois(User* source, User* dest)
- {
- if (!clientactive)
- return;
-
- // Bugfix, only send this numeric for *our* SSL users
- if (dest->GetExt("ssl", dummy))
- {
- ServerInstance->SendWhoisLine(source, dest, 320, "%s %s :is using a secure connection", source->nick.c_str(), dest->nick.c_str());
- }
- }
-
- virtual void OnSyncUserMetaData(User* user, Module* proto, void* opaque, const std::string &extname, bool displayable)
- {
- // check if the linking module wants to know about OUR metadata
- if (extname == "ssl")
- {
- // check if this user has an swhois field to send
- if(user->GetExt(extname, dummy))
- {
- // call this function in the linking module, let it format the data how it
- // sees fit, and send it on its way. We dont need or want to know how.
- proto->ProtoSendMetaData(opaque, TYPE_USER, user, extname, displayable ? "Enabled" : "ON");
- }
- }
- }
-
- virtual void OnDecodeMetaData(int target_type, void* target, const std::string &extname, const std::string &extdata)
- {
- // check if its our metadata key, and its associated with a user
- if ((target_type == TYPE_USER) && (extname == "ssl"))
- {
- User* dest = (User*)target;
- // if they dont already have an ssl flag, accept the remote server's
- if (!dest->GetExt(extname, dummy))
- {
- dest->Extend(extname, "ON");
- }
- }
- }
-
bool Handshake(issl_session* session)
{
int ret;
EventHandler *u = ServerInstance->SE->GetRef(session->fd);
if (u)
{
- if (!u->GetExt("ssl", dummy))
- u->Extend("ssl", "ON");
+ u->Extend("ssl");
}
session->status = ISSL_OPEN;
// protocol module has propagated the NICK message.
if ((user->GetIOHook() == this) && (IS_LOCAL(user)))
{
- // Tell whatever protocol module we're using that we need to inform other servers of this metadata NOW.
- ServerInstance->PI->SendMetaData(user, TYPE_USER, "ssl", "on");
-
- VerifyCertificate(&sessions[user->GetFd()], user);
+ ssl_cert* certdata = VerifyCertificate(&sessions[user->GetFd()], user);
if (sessions[user->GetFd()].sess)
user->WriteServ("NOTICE %s :*** You are connected using SSL cipher \"%s\"", user->nick.c_str(), SSL_get_cipher(sessions[user->GetFd()].sess));
+
+ ServerInstance->PI->SendMetaData(user, "ssl", "ON");
+ if (certdata)
+ ServerInstance->PI->SendMetaData(user, "ssl_cert", certdata->GetMetaLine().c_str());
}
}
errno = EIO;
}
- void VerifyCertificate(issl_session* session, Extensible* user)
+ ssl_cert* VerifyCertificate(issl_session* session, Extensible* user)
{
if (!session->sess || !user)
- return;
+ return NULL;
X509* cert;
ssl_cert* certinfo = new ssl_cert;
if (!cert)
{
- certinfo->data.insert(std::make_pair("error","Could not get peer certificate: "+std::string(get_error())));
- return;
+ certinfo->error = "Could not get peer certificate: "+std::string(get_error());
+ return certinfo;
}
- certinfo->data.insert(std::make_pair("invalid", SSL_get_verify_result(session->sess) != X509_V_OK ? ConvToStr(1) : ConvToStr(0)));
+ certinfo->invalid = (SSL_get_verify_result(session->sess) != X509_V_OK);
if (SelfSigned)
{
- certinfo->data.insert(std::make_pair("unknownsigner",ConvToStr(0)));
- certinfo->data.insert(std::make_pair("trusted",ConvToStr(1)));
+ certinfo->unknownsigner = false;
+ certinfo->trusted = true;
}
else
{
- certinfo->data.insert(std::make_pair("unknownsigner",ConvToStr(1)));
- certinfo->data.insert(std::make_pair("trusted",ConvToStr(0)));
+ certinfo->unknownsigner = true;
+ certinfo->trusted = false;
}
- certinfo->data.insert(std::make_pair("dn",std::string(X509_NAME_oneline(X509_get_subject_name(cert),0,0))));
- certinfo->data.insert(std::make_pair("issuer",std::string(X509_NAME_oneline(X509_get_issuer_name(cert),0,0))));
+ certinfo->dn = X509_NAME_oneline(X509_get_subject_name(cert),0,0);
+ certinfo->issuer = X509_NAME_oneline(X509_get_issuer_name(cert),0,0);
if (!X509_digest(cert, digest, md, &n))
{
- certinfo->data.insert(std::make_pair("error","Out of memory generating fingerprint"));
+ certinfo->error = "Out of memory generating fingerprint";
}
else
{
- certinfo->data.insert(std::make_pair("fingerprint",irc::hex(md, n)));
+ certinfo->fingerprint = irc::hex(md, n);
}
if ((ASN1_UTCTIME_cmp_time_t(X509_get_notAfter(cert), ServerInstance->Time()) == -1) || (ASN1_UTCTIME_cmp_time_t(X509_get_notBefore(cert), ServerInstance->Time()) == 0))
{
- certinfo->data.insert(std::make_pair("error","Not activated, or expired certificate"));
+ certinfo->error = "Not activated, or expired certificate";
}
X509_free(cert);
+ return certinfo;
}
void Prioritize()
projects / user / henk / code / inspircd.git / blobdiff