case ClientError::CertificatePathLengthExceededError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate path length constraint exceeded"); break;

case ClientError::InvalidCertificateSignatureError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Invalid certificate signature"); break;

case ClientError::InvalidCAError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Invalid Certificate Authority"); break;

case ClientError::InvalidServerIdentityError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate does not match the host identity"); break;

case ClientError::RevokedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate has been revoked"); break;

case ClientError::RevocationCheckFailedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Unable to determine certificate revocation state"); break;

}

bool forceReconnectAfterCertificateTrust = false;

if (!certificateErrorMessage.empty()) {

forceReconnectAfterCertificateTrust = true;

}

else {

message = QT_TRANSLATE_NOOP("", "Certificate error");

}

}

if (forceReconnectAfterCertificateTrust && settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

forceReconnectAfterCertificateTrust = false;

namespace Swift {

/**

* A certificate trust checker that trusts certificates in a certificate storage.

*/

class CertificateStorageTrustChecker : public CertificateTrustChecker {

public:

CertificateStorageTrustChecker(CertificateStorage* storage) : storage(storage) {

}

}

}

private:

CertificateStorage* storage;

};

}

virtual void setMessage(const std::string&) = 0;

virtual void setIsLoggingIn(bool loggingIn) = 0;

virtual void addAvailableAccount(const std::string& defaultJID, const std::string& defaultPassword, const std::string& defaultCertificate) = 0;

virtual void removeAvailableAccount(const std::string& jid) = 0;

/** The certificate is what is used for login, the certificatePath is used for remembering paths to populate the loginwindow with*/

boost::signal<void (const std::string&, const std::string&, const std::string& /*CertificatePath*/, CertificateWithKey::ref /* clientCertificate */, bool /* remember password*/, bool /* login automatically */)> onLoginRequest;

virtual void setLoginAutomatically(bool loginAutomatically) = 0;

virtual void quit() = 0;

/** Blocking request whether a cert should be permanently trusted.*/

boost::signal<void ()> onCancelLoginRequest;

boost::signal<void ()> onQuitRequest;

boost::signal<void (const std::string&)> onPurgeSavedLoginRequest;

};

}

void QtLoginWindow::resizeEvent(QResizeEvent*) {

emit geometryChanged();

}

void QtLoginWindow::moveEvent(QMoveEvent*) {

emit geometryChanged();

}

QMessageBox dialog(this);

dialog.setText(tr("The certificate presented by the server is not valid."));

dialog.setInformativeText(P2QSTRING(message) + "\n\n" + tr("Would you like to permanently trust this certificate? This must only be done if you know it is correct."));

dialog.setDefaultButton(QMessageBox::No);

}

}

void morphInto(MainWindow *mainWindow);

virtual void loggedOut();

virtual void setShowNotificationToggle(bool);

virtual void setMessage(const std::string& message);

virtual void addAvailableAccount(const std::string& defaultJID, const std::string& defaultPassword, const std::string& defaultCertificate);

virtual void removeAvailableAccount(const std::string& jid);

virtual void setLoginAutomatically(bool loginAutomatically);

virtual void setIsLoggingIn(bool loggingIn);

void selectUser(const std::string& user);

void hide();

QtMenus getMenus() const;

virtual void quit();

signals:

void geometryChanged();

private slots:

void loginClicked();

void QtMainWindow::setConnecting() {

meView_->setConnecting();

}

void QtMainWindow::setStreamEncryptionStatus(bool tlsInPlaceAndValid) {

meView_->setStreamEncryptionStatus(tlsInPlaceAndValid);

}

void QtMainWindow::openCertificateDialog(const std::vector<Certificate::ref>& chain) {

#if defined(SWIFTEN_PLATFORM_MACOSX)

#elif defined(SWIFTEN_PLATFORM_WINDOWS)

#else

#pragma message ("No certificate dialog available on this platform.")

#endif

}

void QtMainWindow::handleAdHocActionTriggered(bool /*checked*/) {

QAction* action = qobject_cast<QAction*>(sender());

assert(action);

DiscoItems::Item command = serverAdHocCommands_[serverAdHocCommandActions_.indexOf(action)];

std::vector<QMenu*> getMenus() {return menus_;}

void setMyNick(const std::string& name);

void setMyJID(const JID& jid);

void setMyAvatarPath(const std::string& path);

void setMyStatusText(const std::string& status);

void setMyStatusType(StatusShow::Type type);

void setConnecting();

void setStreamEncryptionStatus(bool tlsInPlaceAndValid);

void openCertificateDialog(const std::vector<Certificate::ref>& chain);

QtEventWindow* getEventWindow();

QtChatListWindow* getChatListWindow();

void setRosterModel(Roster* roster);

void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& commands);

private slots:

void handleStatusChanged(StatusShow::Type showType, const QString &statusMessage);

void handleSettingChanged(const std::string& settingPath);

void handleShowOfflineToggled(bool);

void handleJoinMUCAction();

state = Authenticating;

authenticator->setCredentials(localJID.getNode(), password);

stream->writeElement(boost::make_shared<AuthRequest>(authenticator->getName(), authenticator->getResponse()));

}

void ClientSession::handleTLSEncrypted() {

checkState(Encrypting);

Certificate::ref certificate = stream->getPeerCertificate();

boost::shared_ptr<CertificateVerificationError> verificationError = stream->getPeerCertificateVerificationError();

if (verificationError) {

}

else {

ServerIdentityVerifier identityVerifier(localJID);

if (identityVerifier.certificateVerifies(certificate)) {

continueAfterTLSEncrypted();

}

else {

}

}

}

continueAfterTLSEncrypted();

}

else {

finishSession(error);

}

}

void ClientSession::continueAfterTLSEncrypted() {

state = WaitingForStreamStart;

void handleTLSEncrypted();

bool checkState(State);

void continueSessionInitialization();

void requestAck();

void handleStanzaAcked(boost::shared_ptr<Stanza> stanza);

void ack(unsigned int handledStanzasCount);

void continueAfterTLSEncrypted();

private:

JID localJID;

State state;

boost::shared_ptr<SessionStream> stream;

bool allowPLAINOverNonTLS;

bool useStreamCompression;

UseTLS useTLS;

bool useAcks;

* A certificate trust checker that trusts any ceritficate.

*

* This can be used to ignore any TLS certificate errors occurring

* during connection.

*

* \see Client::setAlwaysTrustCertificates()

*/

class BlindCertificateTrustChecker : public CertificateTrustChecker {

public:

return true;

}

};

}

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/TLS/Certificate.h>

namespace Swift {

/**

* A class to implement a check for certificate trust.

*/

class CertificateTrustChecker {

public:

virtual ~CertificateTrustChecker();

/**

* This method is called to find out whether a certificate is

* trusted. This usually happens when a certificate's validation

* fails, to check whether to proceed with the connection or not.

*/

};

}