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(); }