QT_USE_NAMESPACE
//! [constructor]
SslEchoServer::SslEchoServer(quint16 port, QObject *parent) :
QObject(parent),
m_pWebSocketServer(Q_NULLPTR),
m_clients()
{
m_pWebSocketServer = new QWebSocketServer("SSL Echo Server", QWebSocketServer::SECURE_MODE, this);
QSslConfiguration sslConfiguration;
QFile certFile(QStringLiteral("./localhost.cert"));
QFile keyFile(QStringLiteral("./localhost.key"));
certFile.open(QIODevice::ReadOnly);
keyFile.open(QIODevice::ReadOnly);
QSslCertificate certificate(&certFile, QSsl::Pem);
QSslKey sslKey(&keyFile, QSsl::Rsa, QSsl::Pem);
certFile.close();
keyFile.close();
sslConfiguration.setProtocol(QSsl::AnyProtocol);
sslConfiguration.setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfiguration.setLocalCertificate(certificate);
sslConfiguration.setPrivateKey(sslKey);
sslConfiguration.setProtocol(QSsl::TlsV1SslV3);
m_pWebSocketServer->setSslConfiguration(sslConfiguration);
if (m_pWebSocketServer->listen(QHostAddress::Any, port))
{
qDebug() << "SSL Echo Server listening on port" << port;
connect(m_pWebSocketServer, SIGNAL(newConnection()), this, SLOT(onNewConnection()));
}
}
void QMQTT::ClientPrivate::init(const QString& hostName, const quint16 port, const bool ssl,
const bool ignoreSelfSigned)
{
_hostName = hostName;
_port = port;
if (ssl)
{
#ifndef QT_NO_SSL
QSslConfiguration sslConf = QSslConfiguration::defaultConfiguration();
QList<QSslCertificate> certs = QSslCertificate::fromPath(QStringLiteral("./cert.crt"));
if (!certs.isEmpty())
sslConf.setLocalCertificate(certs.first());
QFile file(QStringLiteral("./cert.key"));
if (file.open(QIODevice::ReadOnly)) {
sslConf.setPrivateKey(QSslKey(file.readAll(), QSsl::Rsa));
}
sslConf.setPeerVerifyMode(QSslSocket::VerifyNone);
#if QT_VERSION < 0x050000
sslConf.setProtocol(QSsl::TlsV1);
#endif
init(hostName, port, sslConf, ignoreSelfSigned);
#else
Q_UNUSED(ignoreSelfSigned)
qCritical() << "SSL not supported in this QT build";
#endif // QT_NO_SSL
}
else
{
init(new Network);
}
}
itsBrowser::itsBrowser( QWidget *parent ) :
QWebView( parent ){
//This is needed in Ubuntu under QT 5 for SSL to work
//Still need to test in Windows7
QSslConfiguration sslConfig = QSslConfiguration::defaultConfiguration();
sslConfig.setProtocol( QSsl::SslV3 ); //Seems under ubuntu we need to specify the version
QSslConfiguration::setDefaultConfiguration( sslConfig );
QWebSettings *Tsettings = settings();
Tsettings->setAttribute( QWebSettings::JavascriptEnabled , true );
Tsettings->setAttribute( QWebSettings::PluginsEnabled , true );
Tsettings->setAttribute( QWebSettings::AutoLoadImages , true );
Tsettings->setAttribute( QWebSettings::JavaEnabled , true );
Tsettings->setAttribute( QWebSettings::JavascriptCanOpenWindows , true);
QNetworkCookieJar *myjar = new QNetworkCookieJar();
this->page()->networkAccessManager()->setCookieJar(myjar);
connect( page()->networkAccessManager(), SIGNAL( sslErrors( QNetworkReply*, const QList<QSslError> & ) ) ,this,SLOT( handleSslErrors( QNetworkReply*, const QList<QSslError> & ) ) );
connect( page()->networkAccessManager(), SIGNAL( authenticationRequired( QNetworkReply*,QAuthenticator* ) ) , this,SLOT( ProvideAuthentication(QNetworkReply*,QAuthenticator* ) ) );
connect( page()->networkAccessManager(), SIGNAL( proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *)) , this , SLOT( ProvideProxAuthentication( const QNetworkProxy&, QAuthenticator*) ) );
connect( page()->networkAccessManager(), SIGNAL( finished ( QNetworkReply *)),this,SLOT(NetworkTaskfinished (QNetworkReply *)));
}
void HeadlessApplication::getFavoriteThreads() {
// list green + yellow flags
const QUrl url(DefineConsts::FORUM_URL + "/forum1f.php?owntopic=1");
qDebug() << "getFavoriteThreads()";
CookieJar *cookies = new CookieJar();
cookies->loadFromDisk();
QNetworkAccessManager *accessManager = new QNetworkAccessManager();
accessManager->setCookieJar(cookies);
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QSslConfiguration sslConfig = request.sslConfiguration();
sslConfig.setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfig.setPeerVerifyDepth(1);
sslConfig.setProtocol(QSsl::TlsV1);
sslConfig.setSslOption(QSsl::SslOptionDisableSessionTickets, true);
QNetworkReply* reply = accessManager->get(request);
bool ok = connect(reply, SIGNAL(finished()), this, SLOT(checkReplyFav()));
Q_ASSERT(ok);
Q_UNUSED(ok);
}
QNetworkReply* NetworkAccessManager::createRequest(Operation op, const QNetworkRequest& request, QIODevice *outgoingData)
{
QNetworkRequest req(request);
if(!QSslSocket::supportsSsl()) {
if(req.url().scheme().toLower() == QLatin1String("https"))
qCritical() << "Request using https scheme without SSL support";
} else {
QSslConfiguration sslConfig = req.sslConfiguration();
#ifdef U_NAM_DEBUG
qDebug() << Q_FUNC_INFO << "NAM: ssl support, configuring it now.";
#endif
sslConfig.setProtocol(QSsl::TlsV1SslV3);
sslConfig.setPeerVerifyMode(QSslSocket::AutoVerifyPeer);
req.setSslConfiguration(sslConfig);
}
if(op == QNetworkAccessManager::PostOperation) {
QString contentType = req.header(QNetworkRequest::ContentTypeHeader).toString();
if(contentType.isEmpty()) {
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
}
}
return QNetworkAccessManager::createRequest(op, req, outgoingData);
}
QNetworkReply* NetworkAccessManager::createRequest(QNetworkAccessManager::Operation oparation, const QNetworkRequest &request, QIODevice * outgoingData = 0) {
QNetworkRequest new_request(request);
// emulate Firefox, allowing to disable certificate
// verification using an environment variable
if (!strcmp(getenv("IGNORECERT"), "1")) {
QSslConfiguration config = request.sslConfiguration();
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(QSsl::TlsV1);
QNetworkRequest new_request(request);
new_request.setSslConfiguration(config);
}
QHashIterator<QString, QString> item(m_headers);
while (item.hasNext()) {
item.next();
new_request.setRawHeader(item.key().toAscii(), item.value().toAscii());
}
QNetworkReply *reply = QNetworkAccessManager::createRequest(oparation, new_request, outgoingData);
// not sure 100% if this is needed, but just in case
if (!strcmp(getenv("IGNORECERT"), "1"))
reply->ignoreSslErrors();
return reply;
};
void AcceptandPayOfferListPage::RefreshImage()
{
QIcon ButtonIcon(m_placeholderImage);
ui->imageButton->setIcon(ButtonIcon);
if(m_imageList.size() > 0 && m_imageList.at(0) != QString(""))
{
QString parsedURL = m_imageList.at(0).simplified();
m_url = QUrl(parsedURL);
if(m_url.isValid())
{
QNetworkRequest request(m_url);
request.setRawHeader("Accept", "q=0.9,image/webp,*/*;q=0.8");
request.setRawHeader("Cache-Control", "no-cache");
request.setRawHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.71 Safari/537.36");
QSslConfiguration conf = request.sslConfiguration();
conf.setPeerVerifyMode(QSslSocket::VerifyNone);
conf.setProtocol(QSsl::TlsV1_0);
request.setSslConfiguration(conf);
QNetworkReply *reply = m_netwManager->get(request);
reply->ignoreSslErrors();
connect(reply, SIGNAL(finished()), this, SLOT(netwManagerFinished()));
}
}
}
QNetworkReply * CustomNetworkAccessManager ::createRequest ( Operation op, const QNetworkRequest &req, QIODevice * outgoingData ){
QSslConfiguration config = req.sslConfiguration();
config.setPeerVerifyMode(mode);
config.setProtocol(protocol);
QNetworkRequest request(req);
request.setSslConfiguration(config);
return QNetworkAccessManager::createRequest(op, request, outgoingData);
}
void PoolBrowser::getRequest( const QString &urlString )
{
QUrl url ( urlString );
QNetworkRequest req ( url );
QSslConfiguration config = QSslConfiguration::defaultConfiguration();
config.setProtocol(QSsl::SslV3);
req.setSslConfiguration(config);
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/json; charset=utf-8");
m_nam.get(req);
}
void SslClient::ConfigureForLMAX()
{
// configure required session protocol
QSslConfiguration config = ssl_->sslConfiguration();
QSsl::SslProtocol p = config.sessionProtocol();
if( p != proto_ )
config.setProtocol(proto_);
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setSslOption(QSsl::SslOptionDisableServerNameIndication, true);
ssl_->setSslConfiguration(config);
}
QNetworkReply* SubsonicService::Send(const QUrl& url) {
QNetworkRequest request(url);
// Don't try and check the authenticity of the SSL certificate - it'll almost
// certainly be self-signed.
QSslConfiguration sslconfig = QSslConfiguration::defaultConfiguration();
sslconfig.setPeerVerifyMode(QSslSocket::VerifyNone);
if (usesslv3_) {
sslconfig.setProtocol(QSsl::SslV3);
}
request.setSslConfiguration(sslconfig);
QNetworkReply *reply = network_->get(request);
return reply;
}
QNetworkReply* NetworkAccessManager::createRequest(Operation op,
const QNetworkRequest &req,
QIODevice *out){
QNetworkRequest newreq(req);
if(m_SslProtocol != QSsl::UnknownProtocol &&
(req.url().scheme() == QStringLiteral("https") || req.url().scheme() == QStringLiteral("ftps"))){
QSslConfiguration sslConfig = newreq.sslConfiguration();
sslConfig.setProtocol(m_SslProtocol);
newreq.setSslConfiguration(sslConfig);
}
#if 0 //def PASSWORD_MANAGER
if(out && op == QNetworkAccessManager::PostOperation){
QByteArray referer = req.rawHeader("Referer");
QString key = m_Id + QStringLiteral(":") + QUrl::fromEncoded(referer).host();
if(Application::GetAuthData(key).isEmpty()){
QByteArray data = out->readAll();
out->reset();
BoolCallBack callBack = [key, data](bool ok){
if(ok) Application::RegisterAuthData(key, data);
};
ModelessDialog::Question(tr("An authentication has been executed."),
tr("Save this password?"), callBack);
}
}
#endif
QNetworkReply *rep = QNetworkAccessManager::createRequest(op, newreq, out);
// QNetworkReply::error is overloaded.
connect(rep, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(HandleError(QNetworkReply::NetworkError)));
connect(rep, &QNetworkReply::sslErrors,
this, &NetworkAccessManager::HandleSslErrors);
QString type = newreq.header(QNetworkRequest::ContentTypeHeader).value<QString>();
if(type.toLower().contains(QStringLiteral("multipart/form-data;"))){
UploadItem *item = NetworkController::Upload(rep, newreq.header(QNetworkRequest::ContentLengthHeader).value<qint64>());
if(item){
MainWindow *win = Application::GetCurrentWindow();
if(win && win->GetTreeBank()->GetNotifier())
win->GetTreeBank()->GetNotifier()->RegisterUpload(item);
}
}
return rep;
}
bool KIO::Integration::sslConfigFromMetaData(const KIO::MetaData& metadata, QSslConfiguration& sslconfig)
{
bool success = false;
if (metadata.contains(QL1S("ssl_in_use"))) {
const QSsl::SslProtocol sslProto = qSslProtocolFromString(metadata.value(QL1S("ssl_protocol_version")));
QList<QSslCipher> cipherList;
cipherList << QSslCipher(metadata.value(QL1S("ssl_cipher_name")), sslProto);
sslconfig.setCaCertificates(QSslCertificate::fromData(metadata.value(QL1S("ssl_peer_chain")).toUtf8()));
sslconfig.setCiphers(cipherList);
sslconfig.setProtocol(sslProto);
success = sslconfig.isNull();
}
return success;
}
Q_DECL_EXPORT int main(int argc, char *argv[]) {
QCoreApplication app(argc, argv);
app.setOrganizationName("cuteTube Events");
app.setApplicationName("cuteTube Events");
app.setApplicationVersion("0.1.0");
QSslConfiguration config = QSslConfiguration::defaultConfiguration();
config.setProtocol(QSsl::TlsV1);
QSslConfiguration::setDefaultConfiguration(config);
Events events;
events.getEvents();
QObject::connect(&events, SIGNAL(finished()), &app, SLOT(quit()));
return app.exec();
}
QT_USE_NAMESPACE
//! [constructor]
BCWebSocketServer::BCWebSocketServer(quint16 port, QObject *parent) :
QObject(parent),
m_pWebSocketServer(Q_NULLPTR),
m_clients()
{
m_pWebSocketServer = new QWebSocketServer(QStringLiteral("Bitcoin Exchange Server"),
QWebSocketServer::NonSecureMode, //**** To be Changed after setting up OpenSSL
this);
QSslConfiguration sslConfiguration;
QFile certFile(QStringLiteral("./localhost.cert"));
QFile keyFile(QStringLiteral("./localhost.key"));
/*if ( */
certFile.open(stderr, QIODevice::ReadOnly | QIODevice::Text ) ; //&&
keyFile.open(stderr, QIODevice::ReadOnly | QIODevice::Text) ; // )
{
QSslCertificate certificate(&certFile, QSsl::Pem);
QSslKey sslKey(&keyFile, QSsl::Rsa, QSsl::Pem);
certFile.close();
keyFile.close();
sslConfiguration.setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfiguration.setLocalCertificate(certificate);
sslConfiguration.setPrivateKey(sslKey);
sslConfiguration.setProtocol(QSsl::TlsV1SslV3);
m_pWebSocketServer->setSslConfiguration(sslConfiguration);
if (m_pWebSocketServer->listen(QHostAddress::Any, port))
{
qDebug() << "Bitcoin Exchange Server listening on port" << port;
connect(m_pWebSocketServer, &QWebSocketServer::newConnection,
this, &BCWebSocketServer::onNewConnection);
connect(m_pWebSocketServer, &QWebSocketServer::sslErrors,
this, &BCWebSocketServer::onSslErrors);
}
_logged = false;
_lang = NULL;
this->data.rank = 0;
}
}
QString downloadWebPage(const QUrl &url)
{
QNetworkRequest request;
QSslConfiguration config;
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(QSsl::TlsV1SslV3);
request.setSslConfiguration(config);
request.setUrl(url);
QNetworkAccessManager manager;
QNetworkReply *reply = manager.get(request);
QEventLoop eventLoop;
QObject::connect(&manager, SIGNAL(finished(QNetworkReply*)), &eventLoop, SLOT(quit()));
eventLoop.exec(); //block until finish
return reply->readAll();
}
QNetworkReply *NetworkAccessManager::createRequest(Operation op, const QNetworkRequest &request, QIODevice *outgoingData)
{
QNetworkRequest req(request);
QSslConfiguration config;
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(QSsl::TlsV1_0);
req.setSslConfiguration(config);
// set user-agent
if (op == PostOperation){
req.setRawHeader("User-Agent", "IDP");
} else {
req.setRawHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.66 Safari/537.36 LBBROWSER");
}
QNetworkReply *reply = QNetworkAccessManager::createRequest(op, req, outgoingData);
return reply;
}
bool CardReader::setupSsl(QString certificatePath, QString keyPath)
{
// FIXME: This function leaks both QFile objects
QFile *certificateFile = new QFile(certificatePath);
certificateFile->open(QIODevice::ReadOnly);
if(!certificateFile->exists()) {
frontend_error("Certificate file doesn't exist", false);
return false;
}
QList<QSslCertificate> certificateChain = QSslCertificate::fromDevice(certificateFile);
certificateFile->close();
if (certificateChain.size() == 0) {
frontend_error("Invalid certificate chain specified", false);
return false;
}
QFile *keyFile = new QFile(keyPath);
keyFile->open(QIODevice::ReadOnly);
if(!keyFile->exists()) {
frontend_error("Key file doesn't exist", false);
return false;
}
QSslKey key(keyFile, QSsl::Rsa);
keyFile->close();
if(key.isNull()) {
frontend_error("Invalid key specified", false);
return false;
}
QSslConfiguration sslConfiguration = QSslConfiguration::defaultConfiguration();
sslConfiguration.setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfiguration.setProtocol(QSsl::SecureProtocols);
sslConfiguration.setLocalCertificateChain(certificateChain);
sslConfiguration.setPrivateKey(key);
server = new QWebSocketServer(QStringLiteral("Arago Card Reader"), QWebSocketServer::SecureMode, this);
server->setSslConfiguration(sslConfiguration);
return true;
}
void ProfileController::loadProfile(const QString& url) {
// -----------------------------------------------------------------------------------------
// request page
QNetworkRequest request(DefineConsts::FORUM_URL+url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QSslConfiguration sslConfig = request.sslConfiguration();
sslConfig.setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfig.setPeerVerifyDepth(1);
sslConfig.setProtocol(QSsl::TlsV1);
sslConfig.setSslOption(QSsl::SslOptionDisableSessionTickets, true);
request.setSslConfiguration(sslConfig);
QNetworkReply* reply = HFRNetworkAccessManager::get()->get(request);
bool ok = connect(reply, SIGNAL(finished()), this, SLOT(checkReply()));
Q_ASSERT(ok);
Q_UNUSED(ok);
}
//! [1]
void PostHttp::post(const QString &body, const QString &body2)
{
const QUrl url("http://kreativeco.com/marsh/actions/webservices.php?task=login&user="******"&password="******"text/plain");
if (AppSettings::isUsingHttps()) {
request.setUrl(QUrl("http://kreativeco.com/marsh/actions/webservices.php?task=login&user="******"&password=" +body2));
QSslConfiguration config = request.sslConfiguration();
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(QSsl::TlsV1);
request.setSslConfiguration(config);
}
QNetworkReply* reply = m_networkAccessManager->post(request, body.toAscii());
bool ok = connect(reply, SIGNAL(finished()), this, SLOT(onGetReply()));
Q_ASSERT(ok);
Q_UNUSED(ok);
}
//! [1]
void PostHttp::post(const QString &body)
{
const QUrl url("http://httpbin.org/post");
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/plain");
if (AppSettings::isUsingHttps()) {
request.setUrl(QUrl("https://httpbin.org/post"));
QSslConfiguration config = request.sslConfiguration();
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(QSsl::TlsV1);
request.setSslConfiguration(config);
}
QNetworkReply* reply = m_networkAccessManager->post(request, body.toAscii());
bool ok = connect(reply, SIGNAL(finished()), this, SLOT(onGetReply()));
Q_ASSERT(ok);
Q_UNUSED(ok);
}
void SmileyPickerController::getSmiley(const QString &keyword) {
if(keyword.isEmpty())
return;
// list green + yellow flags
const QUrl url(DefineConsts::FORUM_URL + "/message-smi-mp-aj.php?config=hfr.inc&findsmilies=" + keyword);
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QSslConfiguration sslConfig = request.sslConfiguration();
sslConfig.setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfig.setPeerVerifyDepth(1);
sslConfig.setProtocol(QSsl::TlsV1);
sslConfig.setSslOption(QSsl::SslOptionDisableSessionTickets, true);
request.setSslConfiguration(sslConfig);
QNetworkReply* reply = HFRNetworkAccessManager::get()->get(request);
bool ok = connect(reply, SIGNAL(finished()), this, SLOT(checkReply()));
Q_ASSERT(ok);
Q_UNUSED(ok);
// ----------------------------------------------------------------------------------------------
// get the dataModel of the listview if not already available
using namespace bb::cascades;
if(m_ListView == NULL) {
qWarning() << "did not received the listview. quit.";
return;
}
GroupDataModel* dataModel = dynamic_cast<GroupDataModel*>(m_ListView->dataModel());
dataModel->clear();
}
void LanLinkProvider::configureSslSocket(QSslSocket* socket, const QString& deviceId, bool isDeviceTrusted)
{
// Setting supported ciphers manually
// Top 3 ciphers are for new Android devices, botton two are for old Android devices
// FIXME : These cipher suites should be checked whether they are supported or not on device
QList<QSslCipher> socketCiphers;
socketCiphers.append(QSslCipher(QStringLiteral("ECDHE-ECDSA-AES256-GCM-SHA384")));
socketCiphers.append(QSslCipher(QStringLiteral("ECDHE-ECDSA-AES128-GCM-SHA256")));
socketCiphers.append(QSslCipher(QStringLiteral("ECDHE-RSA-AES128-SHA")));
socketCiphers.append(QSslCipher(QStringLiteral("RC4-SHA")));
socketCiphers.append(QSslCipher(QStringLiteral("RC4-MD5")));
// Configure for ssl
QSslConfiguration sslConfig;
sslConfig.setCiphers(socketCiphers);
sslConfig.setProtocol(QSsl::TlsV1_0);
socket->setSslConfiguration(sslConfig);
socket->setLocalCertificate(KdeConnectConfig::instance()->certificate());
socket->setPrivateKey(KdeConnectConfig::instance()->privateKeyPath());
socket->setPeerVerifyName(deviceId);
if (isDeviceTrusted) {
QString certString = KdeConnectConfig::instance()->getDeviceProperty(deviceId, QStringLiteral("certificate"), QString());
socket->addCaCertificate(QSslCertificate(certString.toLatin1()));
socket->setPeerVerifyMode(QSslSocket::VerifyPeer);
} else {
socket->setPeerVerifyMode(QSslSocket::QueryPeer);
}
//Usually SSL errors are only bad for trusted devices. Uncomment this section to log errors in any case, for debugging.
//QObject::connect(socket, static_cast<void (QSslSocket::*)(const QList<QSslError>&)>(&QSslSocket::sslErrors), [](const QList<QSslError>& errors)
//{
// Q_FOREACH (const QSslError &error, errors) {
// qCDebug(KDECONNECT_CORE) << "SSL Error:" << error.errorString();
// }
//});
}
//===================
// PRIVATE
//===================
bool WebServer::setupWebSocket(quint16 port){
WSServer = new QWebSocketServer("sysadm-server", QWebSocketServer::SecureMode, this);
//SSL Configuration
QSslConfiguration config = QSslConfiguration::defaultConfiguration();
QFile CF( QStringLiteral(SSLCERTFILE) );
if(CF.open(QIODevice::ReadOnly) ){
QSslCertificate CERT(&CF,QSsl::Pem);
config.setLocalCertificate( CERT );
CF.close();
}else{
qWarning() << "Could not read WS certificate file:" << CF.fileName();
}
QFile KF( QStringLiteral(SSLKEYFILE));
if(KF.open(QIODevice::ReadOnly) ){
QSslKey KEY(&KF, QSsl::Rsa, QSsl::Pem);
config.setPrivateKey( KEY );
KF.close();
}else{
qWarning() << "Could not read WS key file:" << KF.fileName();
}
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(SSLVERSION);
WSServer->setSslConfiguration(config);
//Setup Connections
connect(WSServer, SIGNAL(newConnection()), this, SLOT(NewSocketConnection()) );
connect(WSServer, SIGNAL(acceptError(QAbstractSocket::SocketError)), this, SLOT(NewConnectError(QAbstractSocket::SocketError)) );
// -- websocket specific signals
connect(WSServer, SIGNAL(closed()), this, SLOT(ServerClosed()) );
connect(WSServer, SIGNAL(serverError(QWebSocketProtocol::CloseCode)), this, SLOT(ServerError(QWebSocketProtocol::CloseCode)) );
connect(WSServer, SIGNAL(originAuthenticationRequired(QWebSocketCorsAuthenticator*)), this, SLOT(OriginAuthRequired(QWebSocketCorsAuthenticator*)) );
connect(WSServer, SIGNAL(peerVerifyError(const QSslError&)), this, SLOT(PeerVerifyError(const QSslError&)) );
connect(WSServer, SIGNAL(sslErrors(const QList<QSslError>&)), this, SLOT(SslErrors(const QList<QSslError>&)) );
connect(WSServer, SIGNAL(acceptError(QAbstractSocket::SocketError)), this, SLOT(ConnectError(QAbstractSocket::SocketError)) );
//Now start the server
return WSServer->listen(QHostAddress::Any, port);
}
void ProtocolController::prepareConnection(QSslSocket *socket)
{
// Ciphers allowed
QList<QSslCipher> ciphers;
ciphers << QSslCipher("ECDHE-RSA-AES256-GCM-SHA384");
// Update config
QSslConfiguration config = socket->sslConfiguration();
config.setProtocol(QSsl::TlsV1_2);
// Set allowed ciphers
config.setCiphers(ciphers);
socket->setSslConfiguration(config);
QFile caFile("certificates/cert.pem");
caFile.open(QIODevice::ReadOnly);
QByteArray data = caFile.readAll();
caFile.close();
QSslCertificate certifacte(data);
socket->addCaCertificate(certifacte);
}
urldownloader::urldownloader(QObject *parent, QNetworkAccessManager* pMan, QString url, QString un, QString pwd) : QObject(parent)
{
m_iErrorCode = 0;
this->m_pMan = pMan;
QNetworkRequest* pNReq = new QNetworkRequest();
QUrl u(url, QUrl::StrictMode);
if(!helpers::str_isempty(un, true)) u.setUserName(un);
if(!helpers::str_isempty(pwd,true)) u.setPassword(pwd);
pNReq->setUrl(u);
pNReq->setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
pNReq->setHeader(QNetworkRequest::UserAgentHeader, "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:33.0) Gecko/20100101 Firefox/33.0");
pNReq->setRawHeader("Accept", "text/html,application/xhtml+xml,application/json,application/xml;q=0.9,*/*;q=0.8");
pNReq->setRawHeader("Host", "outlook.office365.com");
pNReq->setRawHeader("Accept-Language", "de,en-US;q=0.7,en;q=0.3");
pNReq->setRawHeader("Accept-Encoding", "gzip, deflate");
//pNReq->setRawHeader("Cookie", "[email protected]=u56Lnp2ejJqBy57Lmc3LzMvSm56ZydLLns+Z0sfOzZ7Sm8mdm5uanc3PzszPgZGemJ6NjZDRnJCSgc3PzsrSz87Szs6rzszFzc/Fys+Bno+cj42bz8nRj42Qm9GQiouTkJCU0ZyQkg==; [email protected]=u56Lnp2ejJqBy57Lmc3LzMvSm56ZydLLns+Z0sfOzZ7Sm8mdm5uanc3PzszPgZGemJ6NjZDRnJCSgc3PzsrSz87Szs6rzszFzc/Fys8=; ClientId=S8ZGAYKKZUMUUD8Z1GAHUA; RPSAuth=FABKARQl3luxXpSMs941OuaciuqbomfY%2BwNmAAAEgAAACHn%2Bcn5qeThRCAFUFhV4cLRyTxhKnj3Cu9/UurHnSzTjUaVlDJYm%2BQYvG5gQJK/8/zoZ7Ql2l4gPN8g42lt7Q/4qvIm9kuW4Pu7BML9c%2B/%2BbrbgBQt/J0k9SuVs2N05Ttdae%2B%2Bqej/mKA/5Mwu0XHLdZxwjkYNftPQXVA%2BUR35tt6PDDH3IyQ2ETfrJQzq0wEalYIugrYegzPwUoQdnEsaswOEsadSBVLx%2Bp8C%2BRkBC/SRApp4jDexCEy4Vfpfflhqs8ACrDCsjYANA34KdLa2p8TJgYhyc01hqmUSXCK/uKi2bLI70AzhPtIPWH0G09u6hi7NmgsqtpgmwM91oZymAhHxg8zz1zu3kp7KqojW%2BlKIQUAECcHToiItuRNYis%2Be/YQk0rDOV7; RPSSecAuth=FABKARQl3luxXpSMs941OuaciuqbomfY%2BwNmAAAEgAAACFayulSMa1YxCAF20P9w0quS9gl%2BL2ogHL40UIhPjFT7rNpGHzpI1HDUzb7vzElMdFwxn9bNh0b9pmxshVO1cnThVnpSe620285EW7j5cPqQtRhrkh4B9pfns1rGRbCVVncizhPaa0TNnzV98T7qSKVki0JbAIjmo3f8V0SNw6prVwnugAVThyu9zpM6NmTX5azYBihvq5wSmWxEDLXvBFcQ4TPcDfNKLbI3dC243KYjJDfS%2BSEbrc819OCDjIs8BsVttnhNU1y2AKh9p3sSg2t3f8T5nYWdBQajS5qR7WiZkJNJAqUfoYWe9CMMt0QOkHC8axIj140uohggNVZxtEhSeZTBBNqxGM4aWn8cIR0x11AUAPWwpDhKFCQ/8KFVxTfEVDI6xy73; MH=MSFT; exchangecookie=ac8b9135b4d748f0854d00baf15f5175");
//pNReq->setRawHeader("Authorization", "Basic Z2VvcmdlLmhlcmN6ZWdAbmFnYXJyby5jb206XzFTb2Z0Y29u");
QNetworkProxyFactory::setUseSystemConfiguration(true);
{
QSslConfiguration cfg = pNReq->sslConfiguration();
cfg.setProtocol(QSsl::UnknownProtocol);
pNReq->setSslConfiguration(cfg);
}
m_url = u;
m_pNResp = pMan->get(*pNReq);
connect(m_pNResp, SIGNAL(finished()), &m_loop, SLOT(quit()));
connect(m_pNResp, SIGNAL(readyRead()), this, SLOT(slot_downloadReady()));
connect(m_pNResp, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(error(QNetworkReply::NetworkError)));
connect(m_pNResp, SIGNAL(sslErrors(const QList<QSslError>&)), this, SLOT(sslErrors(const QList<QSslError>&)));
m_loop.exec();
}
OAuthWindow::OAuthWindow(QWidget *parent) :
QDialog(parent)
{
consumerKey = "baumgarr-3523";
consumerSecret = "8d5ee175f8a5d3ec";
urlBase = "https://" +global.server;
requestTokenUrl = urlBase + "/oauth";
accessTokenUrl = urlBase + "/oauth";
authorizationUrlBase = urlBase + "/OAuth.action";
callbackUrl = "index.jsp?action=callbackReturn";
struct timeb tmb;
ftime(&tmb);
int time = tmb.time;
int millis = tmb.millitm;
// Create the URLs needed for authentication with Evernote
temporaryCredUrl = "https://"+global.server + "/oauth?oauth_consumer_key=" +consumerKey + "&oauth_signature=" +
consumerSecret + "%26&oauth_signature_method=PLAINTEXT&oauth_timestamp="+QString::number(time)+
"&oauth_nonce="+QString::number(millis) +"&oauth_callback=nnoauth";
permanentCredUrl = "https://"+global.server + "/oauth?oauth_consumer_key=" +consumerKey + "&oauth_signature=" +
consumerSecret + "%26&oauth_signature_method=PLAINTEXT&oauth_timestamp="+QString::number(time)+
"&oauth_nonce="+QString::number(millis) +"&oauth_token=";
// Build the window
setWindowTitle(tr("Please Grant NixNote Access"));
setWindowIcon(QIcon(":password.png"));
setLayout(&grid);
grid.addWidget(&userLoginPage);
error = false;
errorMessage = "";
// Check that SSL sockets are supported
if (!QSslSocket::supportsSsl()) {
errorMessage = tr("SSL Support not found. Aborting connection");
error = true;
close();
return;
}
// Turn on TLS (sometimes it isn't on by default)
QSslConfiguration config = QSslConfiguration::defaultConfiguration();
config.setProtocol(QSsl::TlsV1);
config.setProtocol(QSsl::SslV3);
QSslConfiguration::setDefaultConfiguration(config);
// Since this page loads async, we need flags to be sure we don't load something twice
authTokenReceived = false;
userLoginPageLoaded = false;
// Load the temporary URL to start the authentication procesess. When
// finished, this QWebView will contain the URL to start the
// authentication process.
QUrl tu(temporaryCredUrl);
connect(&tempAuthPage, SIGNAL(loadFinished(bool)), this, SLOT(tempAuthPageLoaded(bool)));
connect(tempAuthPage.page()->networkAccessManager(),SIGNAL(finished(QNetworkReply*)), this, SLOT(tempAuthPageReply(QNetworkReply*)));
QLOG_DEBUG() << "Temporary URL:" << tu.toString();
tempAuthPage.load(tu);
}
ReceiveCoinsDialog::ReceiveCoinsDialog(const PlatformStyle* platformStyle, QWidget* parent)
: QDialog(parent)
, ui(new Ui::ReceiveCoinsDialog)
, model(0)
, platformStyle(platformStyle)
#if defined(HAVE_WEBENGINE_VIEW) || defined(HAVE_WEBKIT)
, buyView(NULL)
#endif
, buyReceiveAddress(NULL)
, currentAccount(NULL)
{
ui->setupUi(this);
ui->accountRequestPaymentButton->setCursor(Qt::PointingHandCursor);
ui->accountBuyGuldenButton->setCursor(Qt::PointingHandCursor);
ui->accountBuyButton->setCursor(Qt::PointingHandCursor);
ui->accountSaveQRButton->setCursor(Qt::PointingHandCursor);
ui->accountCopyToClipboardButton->setCursor(Qt::PointingHandCursor);
ui->cancelButton->setCursor(Qt::PointingHandCursor);
ui->closeButton->setCursor(Qt::PointingHandCursor);
ui->generateRequestButton->setCursor(Qt::PointingHandCursor);
ui->generateAnotherRequestButton->setCursor(Qt::PointingHandCursor);
connect(ui->accountCopyToClipboardButton, SIGNAL(clicked()), this, SLOT(copyAddressToClipboard()));
connect(ui->accountBuyGuldenButton, SIGNAL(clicked()), this, SLOT(showBuyGuldenDialog()));
connect(ui->accountBuyButton, SIGNAL(clicked()), this, SLOT(buyGulden()));
connect(ui->accountSaveQRButton, SIGNAL(clicked()), this, SLOT(saveQRAsImage()));
connect(ui->accountRequestPaymentButton, SIGNAL(clicked()), this, SLOT(gotoRequestPaymentPage()));
connect(ui->generateAnotherRequestButton, SIGNAL(clicked()), this, SLOT(gotoRequestPaymentPage()));
connect(ui->cancelButton, SIGNAL(clicked()), this, SLOT(cancelRequestPayment()));
connect(ui->closeButton, SIGNAL(clicked()), this, SLOT(cancelRequestPayment()));
connect(ui->generateRequestButton, SIGNAL(clicked()), this, SLOT(generateRequest()));
updateAddress("");
gotoReceievePage();
#ifdef HAVE_WEBENGINE_VIEW
buyView = new WebEngineView(this);
buyView->setAttribute(Qt::WA_TranslucentBackground);
ui->buyGuldenPageLayout->addWidget(buyView);
buyView->show();
ui->loadingAnimationLabel->setObjectName("buy_page_error_text");
#elif defined(HAVE_WEBKIT)
buyView = new WebView(this);
buyView->settings()->setAttribute(QWebSettings::JavascriptEnabled, true);
buyView->settings()->setAttribute(QWebSettings::JavascriptCanOpenWindows, true);
buyView->settings()->setAttribute(QWebSettings::JavascriptCanCloseWindows, true);
buyView->settings()->setAttribute(QWebSettings::PrivateBrowsingEnabled, true);
buyView->settings()->setAttribute(QWebSettings::JavascriptCanAccessClipboard, false);
buyView->settings()->setAttribute(QWebSettings::SpatialNavigationEnabled, true);
buyView->settings()->setAttribute(QWebSettings::LocalContentCanAccessRemoteUrls, true);
buyView->settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, true);
#ifdef MAC_OSX
QSslConfiguration sslCfg = QSslConfiguration::defaultConfiguration();
QList<QSslCertificate> ca_list = sslCfg.caCertificates();
QList<QSslCertificate> ca_new = QSslCertificate::fromData("CaCertificates");
ca_list += ca_new;
sslCfg.setCaCertificates(ca_list);
sslCfg.setProtocol(QSsl::AnyProtocol);
QSslConfiguration::setDefaultConfiguration(sslCfg);
connect(buyView->page()->networkAccessManager(), SIGNAL(sslErrors(QNetworkReply*, const QList<QSslError>&)), this, SLOT(sslErrorHandler(QNetworkReply*, const QList<QSslError>&)));
#endif
ui->buyGuldenPageLayout->addWidget(buyView);
buyView->show();
ui->loadingAnimationLabel->setObjectName("buy_page_error_text");
#else
ui->accountBuyGuldenButton->setVisible(false);
#endif
}
void WebsocketServer::initialisieren(const QString &name, const QString &ipAdresse, const int &anschluss, const QStringList &sslAlgorithmen,
const QStringList &ssl_EK, const QString &ssl_DH, const QString &zertifikatSchluessel,
const QString &zertifikat, const QString &zertifkatKette, const bool &ssl_aktiv)
{
QWebSocketServer::SslMode SSL_Modus;
if (ssl_aktiv)
{
SSL_Modus=QWebSocketServer::SecureMode;
K_IPAdresse=QHostAddress(ipAdresse);
}
else
{
SSL_Modus=QWebSocketServer::NonSecureMode;
K_IPAdresse=QHostAddress(QHostAddress::LocalHost);
}
K_Server=new QWebSocketServer(name,SSL_Modus,this);
connect(K_Server,&QWebSocketServer::sslErrors,this, &WebsocketServer::SSL_Fehler);
connect(K_Server,&QWebSocketServer::serverError,this,&WebsocketServer::SSL_Serverfehler);
connect(K_Server,&QWebSocketServer::newConnection,this,&WebsocketServer::NeuerKlient);
connect(K_Server,&QWebSocketServer::acceptError,this,&WebsocketServer::Verbindungsfehler);
K_Anschluss=anschluss;
QSslConfiguration SSL;
QList<QSslCipher> Algorithmen;
QVector<QSslEllipticCurve> EK;
SSL.setProtocol(QSsl::TlsV1_2OrLater);
SSL.setPeerVerifyMode(QSslSocket::VerifyNone);
QSslCipher Algorithmus;
QSslEllipticCurve Kurve;
if (ssl_aktiv)
{
//BUG Das mit der Reihenfolge geht nicht
for (auto Eintrag : sslAlgorithmen)
{
Algorithmus=QSslCipher(Eintrag);
if (Algorithmus.isNull())
qCWarning(qalarm_serverWebsocketServer)<< tr("Algorithmus %1 wird nicht unterstützt.").arg(Eintrag);
else
Algorithmen.append(Algorithmus);
}
SSL.setCiphers(Algorithmen);
//BUG Es werden nie Kurven angeboten
for (auto Eintrag : ssl_EK)
{
Kurve=QSslEllipticCurve::fromShortName(Eintrag);
if (!Kurve.isValid())
qCWarning(qalarm_serverWebsocketServer)<< tr("Kurve %1 wird nicht unterstützt.").arg(Eintrag);
else
EK.append(Kurve);
}
SSL.setEllipticCurves(EK);
if(!ssl_DH.isEmpty())
{
#if (QT_VERSION >= QT_VERSION_CHECK(5,8,0))
SSL.setDiffieHellmanParameters(QSslDiffieHellmanParameters::fromEncoded(DateiLaden(ssl_DH,tr("Die DH Parameter %1 konnten nicht geladen werden."))));
#else
qCWarning(qalarm_serverWebsocketServer)<<tr("Qt kann die DH Parameter erst ab Version 5.8.0 setzen");
#endif
}
QList<QSslCertificate> Zertifikate;
Zertifikate=QSslCertificate::fromDevice(DateiLaden(zertifikat,tr("Zertifikat %1 konnte nicht geladen werden.").arg(zertifikat)));
Zertifikate.append(QSslCertificate::fromDevice(DateiLaden(zertifkatKette,tr("Die Zertifikatskette %1 konnte nicht geladen werden.").arg(zertifkatKette))));
SSL.setLocalCertificateChain(Zertifikate);
SSL.setPrivateKey(QSslKey(DateiLaden(zertifikatSchluessel,tr("Der Schlüssel %1 für das Zertifikat konnte nicht geladen werden.").arg(zertifikatSchluessel)),QSsl::Rsa));
if(SSL.privateKey().isNull() || SSL.localCertificate().isNull() || SSL.localCertificateChain().isEmpty())
return;
qCDebug(qalarm_serverWebsocketServer)<<tr("Setze SSL Konfiguration");
qCDebug(qalarm_serverWebsocketServer)<<tr("Privater Schlüssel: ")<<SSL.privateKey();
qCDebug(qalarm_serverWebsocketServer)<<tr("Zertifikate: ")<<SSL.localCertificateChain();
#if (QT_VERSION >= QT_VERSION_CHECK(5,8,0))
qCDebug(qalarm_serverWebsocketServer)<<tr("DH Parameter: ")<<SSL.diffieHellmanParameters();
#endif
qCDebug(qalarm_serverWebsocketServer)<<tr("Zerttest: ")<<SSL.peerVerifyMode();
qCDebug(qalarm_serverWebsocketServer)<<tr("Elliptische Kurven: ")<<SSL.ellipticCurves();
qCDebug(qalarm_serverWebsocketServer)<<tr("Algorithmen: ")<<SSL.ciphers();
K_Server->setSslConfiguration(SSL);
}
if(!K_Initfehler)
Q_EMIT Initialisiert();
}
