├── LICENSE
├── README.md
├── client.html
├── package.json
├── run-signaling-server.sh
├── signaling-server.js
└── ssl
    ├── server-cert.pem
    ├── server-csr.pem
    └── server-key.pem


/LICENSE:
--------------------------------------------------------------------------------
 1 | This is free and unencumbered software released into the public domain.
 2 | 
 3 | Anyone is free to copy, modify, publish, use, compile, sell, or
 4 | distribute this software, either in source code form or as a compiled
 5 | binary, for any purpose, commercial or non-commercial, and by any
 6 | means.
 7 | 
 8 | In jurisdictions that recognize copyright laws, the author or authors
 9 | of this software dedicate any and all copyright interest in the
10 | software to the public domain. We make this dedication for the benefit
11 | of the public at large and to the detriment of our heirs and
12 | successors. We intend this dedication to be an overt act of
13 | relinquishment in perpetuity of all present and future rights to this
14 | software under copyright law.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 
24 | For more information, please refer to <http://unlicense.org/>
25 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | About
 2 | =====
 3 | 
 4 | This is a "simple", but complete example of how to utilize WebRTC to do peer to
 5 | peer voice and video chatting between two or more people.
 6 | 
 7 | ### Server Side 
 8 | This example uses node.js and socket.io to create a "Signaling Server", which
 9 | runs on (or near) your web server to manage who should talk to who. The purpose
10 | of the signaling server is to relay information between peers while you are
11 | setting them up to talk directly to each other.
12 | 
13 | 
14 | ### Client Side
15 | Included is `client.html` which contains all of the logic to connect to the
16 | signaling server, join a virtual group chat channel, connect with peers, and
17 | stream video and audio to all party members using the raw WebRTC API.
18 | 
19 | 
20 | Running
21 | =======
22 | 
23 | ### Node.js signaling server
24 | You'll need to install `node.js` for the signaling server portion of this code to run.
25 | 
26 | Once node.js is installed, install the packages we need for this demo
27 | ```
28 | npm install
29 | ```
30 | 
31 | Then simply run the signaling server:
32 | ```
33 | npm run start 
34 | ```
35 | 
36 | ### Running the sample
37 | All modern browsers require webrtc stuff to be run over SSL, so this sample uses
38 | a self signed certificate for the signaling server and host of client.html. Because
39 | of this, you'll be presented with a certificate warning when you open the page, simply
40 | click advanced to click accept and the browser should connect to your server.
41 | 
42 | Head to https://localhost:8080/ , or if you are accessing the server from another device,
43 | simply replace `localhost` with the IP or hostname of the server (and click through all
44 | of the certificate warning stuff.)
45 | 
46 | At this point you should be presented with a dialog asking permission to access
47 | your microphone / webcam. Once accepted, you should see a local stream appear
48 | on the page. Now open up the same page in another browser, on the same computer
49 | or another, and watch as the magic of WebRTC takes effect and both images and
50 | audio samples mysteriously move from one browser to the other.  Repeat with as
51 | many browsers as you dare.
52 | 
53 | 
54 | Note: At the time of writing this, only firefox and chrome support WebRTC,
55 | however both browsers support this on Windows, Linux, Mac, and Android, so lots
56 | of fun can be had pointing everyones' phones, tablets, and laptops at that `client.html`
57 | and bogging down your network with audio/video traffic.
58 | 
59 | 
60 | Using things other than jQuery, node.js, and socket.io
61 | =============================================
62 | The choice of node.js and socket.io is based purely on my familiarity with them
63 | and the fact that their fairly easy to understand even if you aren't familiar
64 | with them. However, you can use any mechanisms you want for your signaling system, you
65 | just need a way to exchange ICE candidates and session descriptions between
66 | clients.
67 | 
68 | The use of jQuery is even less important, I just like using it for DOM
69 | manipulation, and we only do that to add and remove the <video>/<audio>
70 | elements in this demo. We don't use it at all for anything WebRTC specific in
71 | this example.
72 | 


--------------------------------------------------------------------------------
/client.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html>
  3 |     <head>
  4 |         <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
  5 |         <style>
  6 |             html, body { 
  7 |                 background-color: #333; 
  8 |             }
  9 |             video {
 10 |                 width:  320px;
 11 |                 height:  240px;
 12 |                 border:  1px solid black;
 13 |             }
 14 |         </style>
 15 | 
 16 |         <script src="https://cdn.socket.io/socket.io-1.4.5.js"></script>
 17 |         <script>
 18 |             /** CONFIG **/
 19 |             //var SIGNALING_SERVER = "http://localhost:8080";
 20 |             var SIGNALING_SERVER = window.location.protocol + "://" + window.location.hostname + (window.location.port ? ":" + window.location.port : "");
 21 |             var USE_AUDIO = true;
 22 |             var USE_VIDEO = true;
 23 |             var DEFAULT_CHANNEL = 'some-global-channel-name';
 24 |             var MUTE_AUDIO_BY_DEFAULT = false;
 25 | 
 26 |             /** You should probably use a different stun server doing commercial stuff **/
 27 |             /** Also see: https://gist.github.com/zziuni/3741933 **/
 28 |             var ICE_SERVERS = [
 29 |                 {urls:"stun:stun.l.google.com:19302"}
 30 |             ];
 31 |         </script>
 32 | 
 33 | 
 34 |         <script>
 35 |             var signaling_socket = null;   /* our socket.io connection to our webserver */
 36 |             var local_media_stream = null; /* our own microphone / webcam */
 37 |             var peers = {};                /* keep track of our peer connections, indexed by peer_id (aka socket.io id) */
 38 |             var peer_media_elements = {};  /* keep track of our <video>/<audio> tags, indexed by peer_id */
 39 | 
 40 |             function init() {
 41 |                 console.log("Connecting to signaling server");
 42 |                 signaling_socket = io(SIGNALING_SERVER);
 43 |                 signaling_socket = io();
 44 | 
 45 |                 signaling_socket.on('connect', function() {
 46 |                     console.log("Connected to signaling server");
 47 |                     setup_local_media(function() {
 48 |                         /* once the user has given us access to their
 49 |                          * microphone/camcorder, join the channel and start peering up */
 50 |                         join_chat_channel(DEFAULT_CHANNEL, {'whatever-you-want-here': 'stuff'});
 51 |                     });
 52 |                 });
 53 |                 signaling_socket.on('disconnect', function() {
 54 |                     console.log("Disconnected from signaling server");
 55 |                     /* Tear down all of our peer connections and remove all the
 56 |                      * media divs when we disconnect */
 57 |                     for (peer_id in peer_media_elements) {
 58 |                         peer_media_elements[peer_id].remove();
 59 |                     }
 60 |                     for (peer_id in peers) {
 61 |                         peers[peer_id].close();
 62 |                     }
 63 | 
 64 |                     peers = {};
 65 |                     peer_media_elements = {};
 66 |                 });
 67 |                 function join_chat_channel(channel, userdata) {
 68 |                     signaling_socket.emit('join', {"channel": channel, "userdata": userdata});
 69 |                 }
 70 |                 function part_chat_channel(channel) {
 71 |                     signaling_socket.emit('part', channel);
 72 |                 }
 73 | 
 74 | 
 75 |                 /** 
 76 |                 * When we join a group, our signaling server will send out 'addPeer' events to each pair
 77 |                 * of users in the group (creating a fully-connected graph of users, ie if there are 6 people
 78 |                 * in the channel you will connect directly to the other 5, so there will be a total of 15 
 79 |                 * connections in the network). 
 80 |                 */
 81 |                 signaling_socket.on('addPeer', function(config) {
 82 |                     console.log('Signaling server said to add peer:', config);
 83 |                     var peer_id = config.peer_id;
 84 |                     if (peer_id in peers) {
 85 |                         /* This could happen if the user joins multiple channels where the other peer is also in. */
 86 |                         console.log("Already connected to peer ", peer_id);
 87 |                         return;
 88 |                     }
 89 |                     var peer_connection = new RTCPeerConnection(
 90 |                         {"iceServers": ICE_SERVERS},
 91 |                         {"optional": [{"DtlsSrtpKeyAgreement": true}]} /* this will no longer be needed by chrome
 92 |                                                                         * eventually (supposedly), but is necessary 
 93 |                                                                         * for now to get firefox to talk to chrome */
 94 |                     );
 95 |                     peers[peer_id] = peer_connection;
 96 | 
 97 |                     peer_connection.onicecandidate = function(event) {
 98 |                         if (event.candidate) {
 99 |                             signaling_socket.emit('relayICECandidate', {
100 |                                 'peer_id': peer_id, 
101 |                                 'ice_candidate': {
102 |                                     'sdpMLineIndex': event.candidate.sdpMLineIndex,
103 |                                     'candidate': event.candidate.candidate
104 |                                 }
105 |                             });
106 |                         }
107 |                     }
108 |                     peer_connection.ontrack = function(event) {
109 |                         console.log("ontrack", event);
110 |                         var remote_media = USE_VIDEO ? $("<video>") : $("<audio>");
111 |                         remote_media.attr("autoplay", "autoplay");
112 |                         if (MUTE_AUDIO_BY_DEFAULT) {
113 |                             remote_media.attr("muted", "true");
114 |                         }
115 |                         remote_media.attr("controls", "");
116 |                         peer_media_elements[peer_id] = remote_media;
117 |                         $('body').append(remote_media);
118 |                         attachMediaStream(remote_media[0], event.streams[0]);
119 |                     }
120 | 
121 |                     /* Add our local stream */
122 |                     peer_connection.addStream(local_media_stream);
123 | 
124 |                     /* Only one side of the peer connection should create the
125 |                      * offer, the signaling server picks one to be the offerer. 
126 |                      * The other user will get a 'sessionDescription' event and will
127 |                      * create an offer, then send back an answer 'sessionDescription' to us
128 |                      */
129 |                     if (config.should_create_offer) {
130 |                         console.log("Creating RTC offer to ", peer_id);
131 |                         peer_connection.createOffer(
132 |                             function (local_description) { 
133 |                                 console.log("Local offer description is: ", local_description);
134 |                                 peer_connection.setLocalDescription(local_description,
135 |                                     function() { 
136 |                                         signaling_socket.emit('relaySessionDescription', 
137 |                                             {'peer_id': peer_id, 'session_description': local_description});
138 |                                         console.log("Offer setLocalDescription succeeded"); 
139 |                                     },
140 |                                     function() { Alert("Offer setLocalDescription failed!"); }
141 |                                 );
142 |                             },
143 |                             function (error) {
144 |                                 console.log("Error sending offer: ", error);
145 |                             });
146 |                     }
147 |                 });
148 | 
149 | 
150 |                 /** 
151 |                  * Peers exchange session descriptions which contains information
152 |                  * about their audio / video settings and that sort of stuff. First
153 |                  * the 'offerer' sends a description to the 'answerer' (with type
154 |                  * "offer"), then the answerer sends one back (with type "answer").  
155 |                  */
156 |                 signaling_socket.on('sessionDescription', function(config) {
157 |                     console.log('Remote description received: ', config);
158 |                     var peer_id = config.peer_id;
159 |                     var peer = peers[peer_id];
160 |                     var remote_description = config.session_description;
161 |                     console.log(config.session_description);
162 | 
163 |                     var desc = new RTCSessionDescription(remote_description);
164 |                     var stuff = peer.setRemoteDescription(desc, 
165 |                         function() {
166 |                             console.log("setRemoteDescription succeeded");
167 |                             if (remote_description.type == "offer") {
168 |                                 console.log("Creating answer");
169 |                                 peer.createAnswer(
170 |                                     function(local_description) {
171 |                                         console.log("Answer description is: ", local_description);
172 |                                         peer.setLocalDescription(local_description,
173 |                                             function() { 
174 |                                                 signaling_socket.emit('relaySessionDescription', 
175 |                                                     {'peer_id': peer_id, 'session_description': local_description});
176 |                                                 console.log("Answer setLocalDescription succeeded");
177 |                                             },
178 |                                             function() { Alert("Answer setLocalDescription failed!"); }
179 |                                         );
180 |                                     },
181 |                                     function(error) {
182 |                                         console.log("Error creating answer: ", error);
183 |                                         console.log(peer);
184 |                                     });
185 |                             }
186 |                         },
187 |                         function(error) {
188 |                             console.log("setRemoteDescription error: ", error);
189 |                         }
190 |                     );
191 |                     console.log("Description Object: ", desc);
192 | 
193 |                 });
194 | 
195 |                 /**
196 |                  * The offerer will send a number of ICE Candidate blobs to the answerer so they 
197 |                  * can begin trying to find the best path to one another on the net.
198 |                  */
199 |                 signaling_socket.on('iceCandidate', function(config) {
200 |                     var peer = peers[config.peer_id];
201 |                     var ice_candidate = config.ice_candidate;
202 |                     peer.addIceCandidate(new RTCIceCandidate(ice_candidate));
203 |                 });
204 | 
205 | 
206 |                 /**
207 |                  * When a user leaves a channel (or is disconnected from the
208 |                  * signaling server) everyone will recieve a 'removePeer' message
209 |                  * telling them to trash the media channels they have open for those
210 |                  * that peer. If it was this client that left a channel, they'll also
211 |                  * receive the removePeers. If this client was disconnected, they
212 |                  * wont receive removePeers, but rather the
213 |                  * signaling_socket.on('disconnect') code will kick in and tear down
214 |                  * all the peer sessions.
215 |                  */
216 |                 signaling_socket.on('removePeer', function(config) {
217 |                     console.log('Signaling server said to remove peer:', config);
218 |                     var peer_id = config.peer_id;
219 |                     if (peer_id in peer_media_elements) {
220 |                         peer_media_elements[peer_id].remove();
221 |                     }
222 |                     if (peer_id in peers) {
223 |                         peers[peer_id].close();
224 |                     }
225 | 
226 |                     delete peers[peer_id];
227 |                     delete peer_media_elements[config.peer_id];
228 |                 });
229 |             }
230 | 
231 | 
232 | 
233 | 
234 |             /***********************/
235 |             /** Local media stuff **/
236 |             /***********************/
237 |             function setup_local_media(callback, errorback) {
238 |                 if (local_media_stream != null) {  /* ie, if we've already been initialized */
239 |                     if (callback) callback();
240 |                     return; 
241 |                 }
242 |                 /* Ask user for permission to use the computers microphone and/or camera, 
243 |                  * attach it to an <audio> or <video> tag if they give us access. */
244 |                 console.log("Requesting access to local audio / video inputs");
245 | 
246 | 
247 |                 navigator.getUserMedia = ( navigator.getUserMedia ||
248 |                        navigator.webkitGetUserMedia ||
249 |                        navigator.mozGetUserMedia ||
250 |                        navigator.msGetUserMedia);
251 | 
252 |                 attachMediaStream = function(element, stream) {
253 |                     console.log('DEPRECATED, attachMediaStream will soon be removed.');
254 |                     element.srcObject = stream;
255 |                  };
256 | 
257 |                 navigator.mediaDevices.getUserMedia({"audio":USE_AUDIO, "video":USE_VIDEO})
258 |                     .then(function(stream) { /* user accepted access to a/v */
259 |                         console.log("Access granted to audio/video");
260 |                         local_media_stream = stream;
261 |                         var local_media = USE_VIDEO ? $("<video>") : $("<audio>");
262 |                         local_media.attr("autoplay", "autoplay");
263 |                         local_media.attr("muted", "true"); /* always mute ourselves by default */
264 |                         local_media.attr("controls", "");
265 |                         $('body').append(local_media);
266 |                         attachMediaStream(local_media[0], stream);
267 | 
268 |                         if (callback) callback();
269 |                     })
270 |                     .catch(function() { /* user denied access to a/v */
271 |                         console.log("Access denied for audio/video");
272 |                         alert("You chose not to provide access to the camera/microphone, demo will not work.");
273 |                         if (errorback) errorback();
274 |                     })
275 |             }
276 |         </script>
277 |     </head>
278 |     <body onload='init()'>
279 |         <!-- 
280 |         the <video> and <audio> tags are all added and removed dynamically
281 |         in 'onAddStream', 'setup_local_media', and 'removePeer'/'disconnect'
282 |         -->
283 |     </body>
284 | </html>
285 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "",
 3 |   "version": "",
 4 |   "description": "About =====",
 5 |   "scripts": {
 6 |     "start": "node signaling-server"
 7 |   },
 8 |   "dependencies": {
 9 |     "body-parser": "^1.15.2",
10 |     "express": "^4.14.0",
11 |     "socket.io": "^1.4.8"
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/run-signaling-server.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | 
3 | node signaling-server.js
4 | 


--------------------------------------------------------------------------------
/signaling-server.js:
--------------------------------------------------------------------------------
  1 | /**************/
  2 | /*** CONFIG ***/
  3 | /**************/
  4 | const PORT = 8080;
  5 | 
  6 | 
  7 | /*************/
  8 | /*** SETUP ***/
  9 | /*************/
 10 | const fs = require("fs");
 11 | const express = require('express');
 12 | //var http = require('http');
 13 | const https = require("https");
 14 | const bodyParser = require('body-parser')
 15 | const main = express()
 16 | //const server = http.createServer(main)
 17 | 
 18 | 
 19 | let privateKey, certificate;
 20 | 
 21 | privateKey = fs.readFileSync("ssl/server-key.pem", "utf8");
 22 | certificate = fs.readFileSync("ssl/server-cert.pem", "utf8");
 23 | const credentials = { key: privateKey, cert: certificate };
 24 | const server = https.createServer(credentials, main);
 25 | 
 26 | const io  = require('socket.io').listen(server);
 27 | //io.set('log level', 2);
 28 | 
 29 | server.listen(PORT, null, function() {
 30 |     console.log("Listening on port " + PORT);
 31 | });
 32 | //main.use(express.bodyParser());
 33 | 
 34 | main.get('/', function(req, res){ res.sendFile(__dirname + '/client.html'); });
 35 | // main.get('/index.html', function(req, res){ res.sendfile('newclient.html'); });
 36 | // main.get('/client.html', function(req, res){ res.sendfile('newclient.html'); });
 37 | 
 38 | 
 39 | 
 40 | /*************************/
 41 | /*** INTERESTING STUFF ***/
 42 | /*************************/
 43 | var channels = {};
 44 | var sockets = {};
 45 | 
 46 | /**
 47 |  * Users will connect to the signaling server, after which they'll issue a "join"
 48 |  * to join a particular channel. The signaling server keeps track of all sockets
 49 |  * who are in a channel, and on join will send out 'addPeer' events to each pair
 50 |  * of users in a channel. When clients receive the 'addPeer' even they'll begin
 51 |  * setting up an RTCPeerConnection with one another. During this process they'll
 52 |  * need to relay ICECandidate information to one another, as well as SessionDescription
 53 |  * information. After all of that happens, they'll finally be able to complete
 54 |  * the peer connection and will be streaming audio/video between eachother.
 55 |  */
 56 | io.sockets.on('connection', function (socket) {
 57 |     socket.channels = {};
 58 |     sockets[socket.id] = socket;
 59 | 
 60 |     console.log("["+ socket.id + "] connection accepted");
 61 |     socket.on('disconnect', function () {
 62 |         for (var channel in socket.channels) {
 63 |             part(channel);
 64 |         }
 65 |         console.log("["+ socket.id + "] disconnected");
 66 |         delete sockets[socket.id];
 67 |     });
 68 | 
 69 | 
 70 |     socket.on('join', function (config) {
 71 |         console.log("["+ socket.id + "] join ", config);
 72 |         var channel = config.channel;
 73 |         var userdata = config.userdata;
 74 | 
 75 |         if (channel in socket.channels) {
 76 |             console.log("["+ socket.id + "] ERROR: already joined ", channel);
 77 |             return;
 78 |         }
 79 | 
 80 |         if (!(channel in channels)) {
 81 |             channels[channel] = {};
 82 |         }
 83 | 
 84 |         for (id in channels[channel]) {
 85 |             channels[channel][id].emit('addPeer', {'peer_id': socket.id, 'should_create_offer': false});
 86 |             socket.emit('addPeer', {'peer_id': id, 'should_create_offer': true});
 87 |         }
 88 | 
 89 |         channels[channel][socket.id] = socket;
 90 |         socket.channels[channel] = channel;
 91 |     });
 92 | 
 93 |     function part(channel) {
 94 |         console.log("["+ socket.id + "] part ");
 95 | 
 96 |         if (!(channel in socket.channels)) {
 97 |             console.log("["+ socket.id + "] ERROR: not in ", channel);
 98 |             return;
 99 |         }
100 | 
101 |         delete socket.channels[channel];
102 |         delete channels[channel][socket.id];
103 | 
104 |         for (id in channels[channel]) {
105 |             channels[channel][id].emit('removePeer', {'peer_id': socket.id});
106 |             socket.emit('removePeer', {'peer_id': id});
107 |         }
108 |     }
109 |     socket.on('part', part);
110 | 
111 |     socket.on('relayICECandidate', function(config) {
112 |         var peer_id = config.peer_id;
113 |         var ice_candidate = config.ice_candidate;
114 |         console.log("["+ socket.id + "] relaying ICE candidate to [" + peer_id + "] ", ice_candidate);
115 | 
116 |         if (peer_id in sockets) {
117 |             sockets[peer_id].emit('iceCandidate', {'peer_id': socket.id, 'ice_candidate': ice_candidate});
118 |         }
119 |     });
120 | 
121 |     socket.on('relaySessionDescription', function(config) {
122 |         var peer_id = config.peer_id;
123 |         var session_description = config.session_description;
124 |         console.log("["+ socket.id + "] relaying session description to [" + peer_id + "] ", session_description);
125 | 
126 |         if (peer_id in sockets) {
127 |             sockets[peer_id].emit('sessionDescription', {'peer_id': socket.id, 'session_description': session_description});
128 |         }
129 |     });
130 | });
131 | 


--------------------------------------------------------------------------------
/ssl/server-cert.pem:
--------------------------------------------------------------------------------
 1 | -----BEGIN CERTIFICATE-----
 2 | MIICNDCCAZ0CFClsmqyDrzNdCz3ZovJJ5ZTaMvt2MA0GCSqGSIb3DQEBCwUAMFkx
 3 | CzAJBgNVBAYTAlVTMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRl
 4 | cm5ldCBXaWRnaXRzIFB0eSBMdGQxEjAQBgNVBAMMCWxvY2FsaG9zdDAeFw0yMTA4
 5 | MTcxMTQ5MDZaFw0yMTA5MTYxMTQ5MDZaMFkxCzAJBgNVBAYTAlVTMRMwEQYDVQQI
 6 | DApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQx
 7 | EjAQBgNVBAMMCWxvY2FsaG9zdDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA
 8 | 9BQmM9DTGiclYiCVGeDbmqthYGg3W29hlCpFOinlC5/u/ZFdkWqyyXvdfBvN2PZS
 9 | Wts3Z7ErUJ/sySciR11NY5g1/6w2RQYyjQn86hIo3ozq0Ce8eaX8oHTugl7OssVz
10 | rqCXmYgJhBgGNlFYAgqETbIbA8ptmPJZHPdFGgFkblMCAwEAATANBgkqhkiG9w0B
11 | AQsFAAOBgQAds4rDxBxDsLiPqq9crhwm2ZlsFXdSbDdLPAwFlly7at+tPgOAw12w
12 | 5ollTFx96my4N9CMy4+6I3DJB/vWDBZ15cAOBUh2xDsbt0MiWF8e45p9aSognJeW
13 | ltBn8gsoq41um6b4fllAmP/CEYVZxURa6I4Yr1mk9m22INa1W1s/4A==
14 | -----END CERTIFICATE-----
15 | 


--------------------------------------------------------------------------------
/ssl/server-csr.pem:
--------------------------------------------------------------------------------
 1 | -----BEGIN CERTIFICATE REQUEST-----
 2 | MIIBmTCCAQICAQAwWTELMAkGA1UEBhMCVVMxEzARBgNVBAgMClNvbWUtU3RhdGUx
 3 | ITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDESMBAGA1UEAwwJbG9j
 4 | YWxob3N0MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQD0FCYz0NMaJyViIJUZ
 5 | 4Nuaq2FgaDdbb2GUKkU6KeULn+79kV2RarLJe918G83Y9lJa2zdnsStQn+zJJyJH
 6 | XU1jmDX/rDZFBjKNCfzqEijejOrQJ7x5pfygdO6CXs6yxXOuoJeZiAmEGAY2UVgC
 7 | CoRNshsDym2Y8lkc90UaAWRuUwIDAQABoAAwDQYJKoZIhvcNAQELBQADgYEASBGq
 8 | RlJcWGV9zmMuTGeLbaKmC2rrufEhQxbeaDMe6C+PHhb7b06ydoRNlCZDoCwB0oJ+
 9 | 0q6EVSSNwJ2K2hiMDDPItRVdxsHYLhYXPU8jGd51UnHKMGoDukmvsCQDIatmUmAi
10 | xZ005whQOkM5C/KboUKTR209uDMa/8cPBuK5oYk=
11 | -----END CERTIFICATE REQUEST-----
12 | 


--------------------------------------------------------------------------------
/ssl/server-key.pem:
--------------------------------------------------------------------------------
 1 | -----BEGIN RSA PRIVATE KEY-----
 2 | MIICXQIBAAKBgQD0FCYz0NMaJyViIJUZ4Nuaq2FgaDdbb2GUKkU6KeULn+79kV2R
 3 | arLJe918G83Y9lJa2zdnsStQn+zJJyJHXU1jmDX/rDZFBjKNCfzqEijejOrQJ7x5
 4 | pfygdO6CXs6yxXOuoJeZiAmEGAY2UVgCCoRNshsDym2Y8lkc90UaAWRuUwIDAQAB
 5 | AoGBAIoFquS6PeYYJOesjSQpJ4X7TAF8bXFjNsbWcHdHoaJFOpxhS4wjzh5p0QGR
 6 | p4H9KOz/8gDNCzV4ein120iH1m5Uqn76yGuqyNUfrEJ11UOxAOXIuVmtg+NoOqw5
 7 | a4P8gXI+TSy4iDz9Fjbl5+O0N3pa3j79UxrBuORgWDuo7T5BAkEA/1roYI85LZy0
 8 | od2lV+wW+jd4001gV8XTX9saml22KIAX6Rw08dj7pD5pA9ryGv7HpdKb30dePLlL
 9 | q6zTp0G0aQJBAPSx83ohvPARcFhrEqVZstWQLOe9eJWoG+J/N8WaiKx/b+y7D6pM
10 | WMelSoZjjD8Fb9EJwQDhX2XGBDzyPasBRVsCQGqfpeozw5dFGLOB3jlxLkL6iKwK
11 | YhEkXFdpIJmWSaptmg5PJdhaVvDE0oq2kGMvQWP/JfC8VyAZ6vvbJWFwcQkCQGH0
12 | Fo6OkO7dXEbY3gb5KGDbrU47h9kJCdiaqr3cxdef0DNJEtVOaL/LCFFR6mOUDpX0
13 | vKFYlvLL2Qh4xHz/Lj8CQQC6XNgHP7dEqRkPWXhlQS4QDZ36EBtZMagzhRA3zNxc
14 | mYFkxe9ktRZgfLP3i7IJWcklpwDijBCFx6pIB+8u6qex
15 | -----END RSA PRIVATE KEY-----
16 | 


--------------------------------------------------------------------------------