Edit File: tlssocket.js
/** * Socket wrapping functions for TLS. * * @author Dave Longley * * Copyright (c) 2009-2012 Digital Bazaar, Inc. */ var forge = require('./forge'); require('./tls'); /** * Wraps a forge.net socket with a TLS layer. * * @param options: * sessionId: a session ID to reuse, null for a new connection if no session * cache is provided or it is empty. * caStore: an array of certificates to trust. * sessionCache: a session cache to use. * cipherSuites: an optional array of cipher suites to use, see * tls.CipherSuites. * socket: the socket to wrap. * virtualHost: the virtual server name to use in a TLS SNI extension. * verify: a handler used to custom verify certificates in the chain. * getCertificate: an optional callback used to get a certificate. * getPrivateKey: an optional callback used to get a private key. * getSignature: an optional callback used to get a signature. * deflate: function(inBytes) if provided, will deflate TLS records using * the deflate algorithm if the server supports it. * inflate: function(inBytes) if provided, will inflate TLS records using * the deflate algorithm if the server supports it. * * @return the TLS-wrapped socket. */ forge.tls.wrapSocket = function(options) { // get raw socket var socket = options.socket; // create TLS socket var tlsSocket = { id: socket.id, // set handlers connected: socket.connected || function(e) {}, closed: socket.closed || function(e) {}, data: socket.data || function(e) {}, error: socket.error || function(e) {} }; // create TLS connection var c = forge.tls.createConnection({ server: false, sessionId: options.sessionId || null, caStore: options.caStore || [], sessionCache: options.sessionCache || null, cipherSuites: options.cipherSuites || null, virtualHost: options.virtualHost, verify: options.verify, getCertificate: options.getCertificate, getPrivateKey: options.getPrivateKey, getSignature: options.getSignature, deflate: options.deflate, inflate: options.inflate, connected: function(c) { // first handshake complete, call handler if(c.handshakes === 1) { tlsSocket.connected({ id: socket.id, type: 'connect', bytesAvailable: c.data.length() }); } }, tlsDataReady: function(c) { // send TLS data over socket return socket.send(c.tlsData.getBytes()); }, dataReady: function(c) { // indicate application data is ready tlsSocket.data({ id: socket.id, type: 'socketData', bytesAvailable: c.data.length() }); }, closed: function(c) { // close socket socket.close(); }, error: function(c, e) { // send error, close socket tlsSocket.error({ id: socket.id, type: 'tlsError', message: e.message, bytesAvailable: 0, error: e }); socket.close(); } }); // handle doing handshake after connecting socket.connected = function(e) { c.handshake(options.sessionId); }; // handle closing TLS connection socket.closed = function(e) { if(c.open && c.handshaking) { // error tlsSocket.error({ id: socket.id, type: 'ioError', message: 'Connection closed during handshake.', bytesAvailable: 0 }); } c.close(); // call socket handler tlsSocket.closed({ id: socket.id, type: 'close', bytesAvailable: 0 }); }; // handle error on socket socket.error = function(e) { // error tlsSocket.error({ id: socket.id, type: e.type, message: e.message, bytesAvailable: 0 }); c.close(); }; // handle receiving raw TLS data from socket var _requiredBytes = 0; socket.data = function(e) { // drop data if connection not open if(!c.open) { socket.receive(e.bytesAvailable); } else { // only receive if there are enough bytes available to // process a record if(e.bytesAvailable >= _requiredBytes) { var count = Math.max(e.bytesAvailable, _requiredBytes); var data = socket.receive(count); if(data !== null) { _requiredBytes = c.process(data); } } } }; /** * Destroys this socket. */ tlsSocket.destroy = function() { socket.destroy(); }; /** * Sets this socket's TLS session cache. This should be called before * the socket is connected or after it is closed. * * The cache is an object mapping session IDs to internal opaque state. * An application might need to change the cache used by a particular * tlsSocket between connections if it accesses multiple TLS hosts. * * @param cache the session cache to use. */ tlsSocket.setSessionCache = function(cache) { c.sessionCache = tls.createSessionCache(cache); }; /** * Connects this socket. * * @param options: * host: the host to connect to. * port: the port to connect to. * policyPort: the policy port to use (if non-default), 0 to * use the flash default. * policyUrl: the policy file URL to use (instead of port). */ tlsSocket.connect = function(options) { socket.connect(options); }; /** * Closes this socket. */ tlsSocket.close = function() { c.close(); }; /** * Determines if the socket is connected or not. * * @return true if connected, false if not. */ tlsSocket.isConnected = function() { return c.isConnected && socket.isConnected(); }; /** * Writes bytes to this socket. * * @param bytes the bytes (as a string) to write. * * @return true on success, false on failure. */ tlsSocket.send = function(bytes) { return c.prepare(bytes); }; /** * Reads bytes from this socket (non-blocking). Fewer than the number of * bytes requested may be read if enough bytes are not available. * * This method should be called from the data handler if there are enough * bytes available. To see how many bytes are available, check the * 'bytesAvailable' property on the event in the data handler or call the * bytesAvailable() function on the socket. If the browser is msie, then the * bytesAvailable() function should be used to avoid race conditions. * Otherwise, using the property on the data handler's event may be quicker. * * @param count the maximum number of bytes to read. * * @return the bytes read (as a string) or null on error. */ tlsSocket.receive = function(count) { return c.data.getBytes(count); }; /** * Gets the number of bytes available for receiving on the socket. * * @return the number of bytes available for receiving. */ tlsSocket.bytesAvailable = function() { return c.data.length(); }; return tlsSocket; };
Back to File Manager