node.js douilles.io avec SSL

Je vais essayer d'obtenir socket.io courir avec mon certificat SSL cependant, il ne se connecte pas.

J'ai basé mon code de fermer l'exemple de discussion:

var https = require('https');
var fs = require('fs');
/**
 * Bootstrap app.
 */
var sys = require('sys')
require.paths.unshift(__dirname + '/../../lib/');

/**
* Module dependencies.
*/

var express = require('express')
  , stylus = require('stylus')
  , nib = require('nib')
  , sio = require('socket.io');

/**
 * App.
 */
var privateKey = fs.readFileSync('../key').toString();
var certificate = fs.readFileSync('../crt').toString();
var ca = fs.readFileSync('../intermediate.crt').toString();

var app = express.createServer({key:privateKey,cert:certificate,ca:ca });


/**
 * App configuration.
 */

...

/**
 * App routes.
 */

app.get('/', function (req, res) {
  res.render('index', { layout: false });
});

/**
 * App listen.
 */

app.listen(443, function () {
  var addr = app.address();
  console.log('   app listening on http://' + addr.address + ':' + addr.port);
});

/**
 * Socket.IO server (single process only)
 */

var io = sio.listen(app,{key:privateKey,cert:certificate,ca:ca});
...

Si je supprime le SSL code, il fonctionne très bien, mais avec ce que je reçois une demande de http://domain.com/socket.io/1/?t=1309967919512

Remarque qu'il ne tente pas de https, ce qui provoque l'échec.

Je suis en essais sur chrome, puisque c'est le navigateur cible pour cette application.

Je m'excuse si c'est une simple question, je suis un node/socket.io débutant.

Merci!

Est-ce votre client tente de se connecter à un " wss://' préfixé URI.
non il ne marche pas en arriver là, il en fait la demande à domain.com/socket.io/1/?t=1309967919512 puis meurt.
Comment êtes-vous en précisant l'adresse à se connecter à? "domain.com" sonne comme un espace réservé dans le support.io client-côté de la bibliothèque. Vous pouvez poster votre client code Javascript que vous utilisez pour vous connecter?
le projet est sur github: github.com/BCCasino/BCCasino
essentiellement parce que ses node.js socket.io comme par magie gère le client trucs du côté, tout ce que vous faire est de lancer socket.connecter
dans github le code en question est test2.js et l'index.jade (backend et frontend respetively)
J'ai essayé de faire une connexion à l'aide de wss uri, elle me donne URISyntaxException. Aucune idée pourquoi?

InformationsquelleAutor Beyond | 2011-07-06

175

Utiliser une URL sécurisée pour votre première connexion, c'est à dire au lieu de "http://" utiliser "https://". Si le WebSocket de transport est choisi, puis de la Prise.IO devrait utiliser "wss://" (SSL) pour la connexion WebSocket trop.

Mise à jour:

Vous pouvez aussi tenter de créer la connexion à l'aide de la "sécuriser" option:
```
var socket = io.connect('https://localhost', {secure: true});
```
- nous faisons cela. nous goto https : // http://www.thebitcoinwheel.com et il a encore fait une requête http automatiquement, c'est quelque chose avec le support.io code et est le point de la question.
- sécurisé:vrai il l'a fait, grâce kanaka!
- Les gars, vous m'a sauvé la vie! Je ne pouvais pas trouver ces options dans la documentation.
- {secure: true} ne devrait pas être nécessaire si vous spécifiez "https" dans l'url. Voici un extrait de socket.io client source secure: 'https' == uri.protocol (version 0.9.16), il définit sécurisé option à true si https est détecté dans l'url.
- J'ai essayé cela avec une URL https et en effet {secure: true} n'était pas nécessaire pour fonctionner correctement.
- Je crois qu'il serait prudent de s'assurer que la connexion est sécurisée en utilisant à la fois sécurisé:la vraie et la délivrance d'une url https pour le côté client. De cette façon, peu importe ce que vous savez, il sera d'une connexion sécurisée.
- n'a pas fonctionné pour moi
InformationsquelleAutor kanaka
37

C'est comment j'ai réussi à le mettre en place avec le service express:
```
var fs = require( 'fs' );
var app = require('express')();
var https        = require('https');
var server = https.createServer({
    key: fs.readFileSync('./test_key.key'),
    cert: fs.readFileSync('./test_cert.crt'),
    ca: fs.readFileSync('./test_ca.crt'),
    requestCert: false,
    rejectUnauthorized: false
},app);
server.listen(8080);

var io = require('socket.io').listen(server);

io.sockets.on('connection',function (socket) {
    ...
});

app.get("/", function(request, response){
    ...
})
```
J'espère que cela va sauver quelqu'un moment.

Mise à jour : pour ceux qui utilisent permet de chiffrer l'utilisation de cette
```
var server = https.createServer({ 
                key: fs.readFileSync('privkey.pem'),
                cert: fs.readFileSync('fullchain.pem') 
             },app);
```
- C'est la seule solution qui a fonctionné pour moi. Merci pour économiser mon temps.
- a travaillé très bien pour moi, après un peu d'essais et d'erreurs avec les certs
- c'est une bonne solution pour moi
- Cette solution a fonctionné parfait pour moi, merci. Si vous êtes en utilisant la connexion certs de letsencrypt.org ensuite, vous pouvez utiliser le code suivant.. var server = https.createServer({ key: fs.readFileSync('/etc/letsencrypt/live/domain.name/privkey.pem'), cert: fs.readFileSync('/etc/letsencrypt/live/domain.name/cert.pem'), ca: fs.readFileSync('/etc/letsencrypt/live/domain.name/chain.pem'), requestCert: false, rejectUnauthorized: false },app); server.listen(3000);
- Bravo. C'est la parfaite solution de travail.
- Merci beaucoup pour cette réponse. Il a été d'une aide extraordinaire pour moi.
InformationsquelleAutor emonik
30

Sur la même note, si votre serveur prend en charge à la fois http et https vous pouvez vous connecter en utilisant:
```
var socket = io.connect('//localhost');
```
à détecter automatiquement le navigateur de schéma et vous connecter en utilisant l'adresse http/https en conséquence. quand en https, le transport sera assuré par défaut, comme la connexion à l'aide
```
var socket = io.connect('https://localhost');
```
allons utiliser secure sockets web - wss:// (le {secure: true} est redondant).

pour plus d'informations sur la façon de servir à la fois les protocoles http et https facilement en utilisant le même nœud serveur découvrez cette réponse.

InformationsquelleAutor Kuf
8

Si votre serveur certifié fichier n'est pas de confiance (par exemple, vous pouvez générer le fichier de clés par vous-même avec keytool commande en java), vous devez ajouter l'option supplémentaire rejectUnauthorized
```
var socket = io.connect('https://localhost', {rejectUnauthorized: false});
```
- serait apprécié si vous avez ajouté un exemple expliquant comment vous avez utilisé l'utilitaire keytool pour créer cette clé pour le nœud. 'Cause touches sont si complexes, et il n'y a pas assez de tutoriels à ce sujet.
- keytool est un outil à l'intérieur du Kit de Développement Java (JDK). vous pouvez vous referer ce docs.oracle.com/javase/10/tools/...
InformationsquelleAutor clevertension

vérifier ce point.configuration..

app = module.exports = express();
var httpsOptions = { key: fs.readFileSync('certificates/server.key'), cert: fs.readFileSync('certificates/final.crt') };        
var secureServer = require('https').createServer(httpsOptions, app);
io = module.exports = require('socket.io').listen(secureServer,{pingTimeout: 7000, pingInterval: 10000});
io.set("transports", ["xhr-polling","websocket","polling", "htmlfile"]);
secureServer.listen(3000);

InformationsquelleAutor Jay Jariwala

Côté serveur:

import http from 'http';
import https from 'https';
import SocketIO, { Socket } from 'socket.io';
import fs from 'fs';
import path from 'path';
import { logger } from '../../utils';
const port: number = 3001;
const server: https.Server = https.createServer(
{
cert: fs.readFileSync(path.resolve(__dirname, '../../../ssl/cert.pem')),
key: fs.readFileSync(path.resolve(__dirname, '../../../ssl/key.pem'))
},
(req: http.IncomingMessage, res: http.ServerResponse) => {
logger.info(`request.url: ${req.url}`);
let filePath = '.' + req.url;
if (filePath === './') {
filePath = path.resolve(__dirname, './index.html');
}
const extname = String(path.extname(filePath)).toLowerCase();
const mimeTypes = {
'.html': 'text/html',
'.js': 'text/javascript',
'.json': 'application/json'
};
const contentType = mimeTypes[extname] || 'application/octet-stream';
fs.readFile(filePath, (error: NodeJS.ErrnoException, content: Buffer) => {
if (error) {
res.writeHead(500);
return res.end(error.message);
}
res.writeHead(200, { 'Content-Type': contentType });
res.end(content, 'utf-8');
});
}
);
const io: SocketIO.Server = SocketIO(server);
io.on('connection', (socket: Socket) => {
socket.emit('news', { hello: 'world' });
socket.on('updateTemplate', data => {
logger.info(data);
socket.emit('updateTemplate', { random: data });
});
});
server.listen(port, () => {
logger.info(`Https server is listening on https://localhost:${port}`);
});

Côté Client:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Websocket Secure Connection</title>
</head>
<body>
<div>
<button id='btn'>Send Message</button>
<ul id='messages'></ul>
</div>
<script src='../../../node_modules/socket.io-client/dist/socket.io.js'></script>
<script>
window.onload = function onload() {
const socket = io('https://localhost:3001');
socket.on('news', function (data) {
console.log(data);
});
socket.on('updateTemplate', function onUpdateTemplate(data) {
console.log(data)
createMessage(JSON.stringify(data));
});
const $btn = document.getElementById('btn');
const $messages = document.getElementById('messages');
function sendMessage() {
socket.emit('updateTemplate', Math.random());
}
function createMessage(msg) {
const $li = document.createElement('li');
$li.textContent = msg;
$messages.appendChild($li);
}
$btn.addEventListener('click', sendMessage);
}
</script>
</body>
</html>

InformationsquelleAutor slideshowp2

C'est mon fichier de configuration de nginx et iosocket code. Server(express) est en écoute sur le port 9191. Il fonctionne bien:
nginx fichier de config:

server {
listen       443 ssl;
server_name  localhost;
root   /usr/share/nginx/html/rdist;
location /user/ {
proxy_pass   http://localhost:9191;
}
location /api/ {
proxy_pass   http://localhost:9191;
}
location /auth/ {
proxy_pass   http://localhost:9191;
}
location / {
index  index.html index.htm;
if (!-e $request_filename){
rewrite ^(.*)$ /index.html break;
}
}
location /socket.io/ {
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_pass   http://localhost:9191/socket.io/;
}
error_page   500 502 503 504  /50x.html;
location = /50x.html {
root   /usr/share/nginx/html;
}
ssl_certificate /etc/nginx/conf.d/sslcert/xxx.pem;
ssl_certificate_key /etc/nginx/conf.d/sslcert/xxx.key;
}

Serveur:

const server = require('http').Server(app)
const io = require('socket.io')(server)
io.on('connection', (socket) => {
handleUserConnect(socket)
socket.on("disconnect", () => {
handleUserDisConnect(socket)
});
})
server.listen(9191, function () {
console.log('Server listening on port 9191')
})

Client(réagir):

    const socket = io.connect('', { secure: true, query: `userId=${this.props.user._id}` })
socket.on('notifications', data => {
console.log('Get messages from back end:', data)
this.props.mergeNotifications(data)
})

Il fonctionne bien quand j'accède à mon https domaine.

InformationsquelleAutor Kathy

0

Pour les applications d'entreprise, il convient de noter que vous ne devriez pas être la manipulation de https dans votre code. Il doit être mis à niveau automatique via IIS ou nginx. L'application ne sais pas ce que sont les protocoles utilisés.

InformationsquelleAutor Urasquirrel

Vous devez vous connecter pour publier un commentaire.