Server.cpp 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646
  1. #include <openssl/ssl.h>
  2. #include <openssl/err.h>
  3. #include "Server.h"
  4. #ifndef WIN32
  5. #include <string.h>
  6. #endif
  7. #include <Key.h>
  8. #include <Text.h>
  9. #include <iostream>
  10. using namespace Network;
  11. // Inhalt der Server Klasse aus Server.h
  12. // Konstruktor
  13. Server::Server()
  14. : ReferenceCounter()
  15. {
  16. sock = 0;
  17. memset(&addresse, 0, sizeof(addresse)); // Adresse setzen
  18. addresse.sin_family = AF_INET;
  19. addresse.sin_addr.s_addr = ADDR_ANY;
  20. klients = 0;
  21. }
  22. // Destruktor
  23. Server::~Server()
  24. {
  25. trenne();
  26. }
  27. // nicht constant
  28. bool Server::verbinde(unsigned short port, int warteschlangenLen) // Öffnet das Socket
  29. {
  30. sock = socket(AF_INET, SOCK_STREAM, 0); // Socket erstellen
  31. addresse.sin_port = htons(port); // port setzen
  32. if (bind(sock, (struct sockaddr*)&addresse, sizeof(addresse)) == -1) // socket öffnen
  33. {
  34. trenne();
  35. return 0; // Fehler
  36. }
  37. if (listen(sock, warteschlangenLen) == -1) // Klients annehmen
  38. {
  39. trenne();
  40. return 0; // Fehler
  41. }
  42. return 1;
  43. }
  44. SKlient* Server::getKlient() // nimmt Klient an
  45. {
  46. if (!sock)
  47. return 0;
  48. sockaddr_in client;
  49. int len = sizeof(addresse);
  50. fd_set set;
  51. int rv = 0;
  52. struct timeval timeout;
  53. while (rv == 0 && sock)
  54. {
  55. FD_ZERO(&set); /* clear the set */
  56. FD_SET(sock, &set); /* add our file descriptor to the set */
  57. timeout.tv_sec = 10;
  58. timeout.tv_usec = 0;
  59. rv = select((int)sock + 1, &set, NULL, NULL, &timeout);
  60. if (rv == -1) return 0;
  61. }
  62. if (!sock) return 0;
  63. #ifdef WIN32
  64. SOCKET cls = accept(sock, (sockaddr*)&client, &len); // Klient empfangen
  65. if (cls == INVALID_SOCKET)
  66. {
  67. trenne();
  68. return 0;
  69. }
  70. #else
  71. SOCKET cls = accept(sock, (sockaddr*)&client, (socklen_t*)&len); // Klient empfangen
  72. if (!cls)
  73. {
  74. if (errno == ECONNABORTED || errno == EBADF)
  75. trenne();
  76. return 0;
  77. }
  78. #endif
  79. client.sin_port = addresse.sin_port;
  80. klients++;
  81. return new SKlient(client, cls); // Klient Handle Klasse zurückgeben
  82. }
  83. int Server::getKlients(bool reset) // gibt die Anzahl der Klients zurück
  84. {
  85. int ret = klients;
  86. if (reset)
  87. klients = 0;
  88. return ret;
  89. }
  90. bool Server::trenne() // beendet den Server
  91. {
  92. if (!sock)
  93. return 1;
  94. if (closesocket(sock) < 0) // socket schließen
  95. return 0;
  96. sock = 0;
  97. return 1;
  98. }
  99. // constant
  100. unsigned short Server::getPort() const // gibt den Port zurück
  101. {
  102. return htons(addresse.sin_port);
  103. }
  104. bool Server::isConnected() const // giebt 1 zurück, falls der Server verbunden ist
  105. {
  106. return sock != 0;
  107. }
  108. // Inhalt der SKlient Klasse aus Server.h
  109. // Konstruktor
  110. SKlient::SKlient(sockaddr_in addresse, SOCKET sock)
  111. : ReferenceCounter()
  112. {
  113. clientAddr = addresse;
  114. this->sock = sock;
  115. downStreamBytes = 0;
  116. upStreamBytes = 0;
  117. sendeKey = 0;
  118. empfangKey = 0;
  119. }
  120. // Destruktor
  121. SKlient::~SKlient()
  122. {
  123. trenne();
  124. if (sendeKey)
  125. sendeKey->release();
  126. if (empfangKey)
  127. empfangKey->release();
  128. }
  129. // nicht constant
  130. void SKlient::setEmpfangTimeout(int miliseconds) // Setzt ein timeout fürs empfangen von daten
  131. {
  132. #ifdef WIN32
  133. DWORD timeout = miliseconds;
  134. setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof timeout);
  135. #else
  136. struct timeval tv;
  137. tv.tv_sec = miliseconds / 1000;
  138. tv.tv_usec = (miliseconds % 1000) * 1000;
  139. setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof tv);
  140. #endif
  141. }
  142. void SKlient::setSendeKeyZ(Encryption::Key* key) // Setzt den Key fürs Senden
  143. {
  144. if (sendeKey)
  145. sendeKey->release();
  146. sendeKey = key;
  147. }
  148. void SKlient::setEmpfangKeyZ(Encryption::Key* key) // Setzt den Key fürs Empfangen
  149. {
  150. if (empfangKey)
  151. empfangKey->release();
  152. empfangKey = key;
  153. }
  154. void SKlient::setSendeKey(const char* key, int len) // Setzt den Key fürs Senden
  155. {
  156. if (!sendeKey)
  157. sendeKey = new Encryption::Key();
  158. sendeKey->setKey(key, len);
  159. }
  160. void SKlient::setEmpfangKey(const char* key, int len) // Setzt den Key fürs Empfangen
  161. {
  162. if (!empfangKey)
  163. empfangKey = new Encryption::Key();
  164. empfangKey->setKey(key, len);
  165. }
  166. bool SKlient::sende(const char* nachricht, int len) // sendet zum Klient
  167. {
  168. if (!sock)
  169. return 0;
  170. int ll = 0;
  171. while (len > 0)
  172. {
  173. #ifdef WIN32
  174. int l = send(sock, nachricht + ll, len, 0);
  175. #else
  176. int l = (int)send(sock, nachricht + ll, len, MSG_NOSIGNAL);
  177. #endif
  178. if (l <= 0)
  179. return 0; // Fehler
  180. len -= l;
  181. ll += l;
  182. }
  183. upStreamBytes += ll;
  184. return 1;
  185. }
  186. bool SKlient::getNachricht(char* nachricht, int len) // empfängt Nachricht von Klient
  187. {
  188. if (!sock)
  189. return 0;
  190. int ll = 0;
  191. while (len > 0)
  192. {
  193. int l = (int)recv(sock, nachricht + ll, len, MSG_WAITALL);
  194. if (l <= 0)
  195. return 0; // Fehler
  196. len -= l;
  197. ll += l;
  198. }
  199. downStreamBytes += ll;
  200. return 1;
  201. }
  202. bool SKlient::sendeEncrypted(const char* nachricht, int len) // sendet zum Server
  203. {
  204. if (!sendeKey)
  205. return sende(nachricht, len);
  206. Encryption::Bytes* n = new Encryption::Bytes(nachricht, len);
  207. sendeKey->codieren(dynamic_cast<Encryption::Bytes*>(n->getThis())); int ll = 0;
  208. while (len > 0)
  209. {
  210. #ifdef WIN32
  211. int l = send(sock, n->getBytes() + ll, len, 0);
  212. #else
  213. int l = (int)send(sock, n->getBytes() + ll, len, MSG_NOSIGNAL);
  214. #endif
  215. if (l <= 0)
  216. {
  217. n->release();
  218. return 0; // Fehler
  219. }
  220. len -= l;
  221. ll += l;
  222. }
  223. upStreamBytes += ll;
  224. n->release();
  225. return 1;
  226. }
  227. bool SKlient::getNachrichtEncrypted(char* nachricht, int len) // empfängt Nachricht
  228. {
  229. if (!empfangKey)
  230. return getNachricht(nachricht, len);
  231. int ll = 0;
  232. while (len > 0)
  233. {
  234. int l = (int)recv(sock, nachricht + ll, len, MSG_WAITALL);
  235. if (l <= 0)
  236. return 0; // Fehler
  237. len -= l;
  238. ll += l;
  239. }
  240. Encryption::Bytes* n = new Encryption::Bytes();
  241. n->setBytesZ(nachricht, ll);
  242. empfangKey->decodieren(n);
  243. downStreamBytes += ll;
  244. return 1;
  245. }
  246. int SKlient::getDownloadBytes(bool reset) // gibt die anzahl von empfangen bytes zurück
  247. {
  248. int ret = downStreamBytes;
  249. if (reset)
  250. downStreamBytes = 0;
  251. return ret;
  252. }
  253. int SKlient::getUploadBytes(bool reset) // gibt die anzahl von versendeter bytes zurück
  254. {
  255. int ret = upStreamBytes;
  256. if (reset)
  257. upStreamBytes = 0;
  258. return ret;
  259. }
  260. bool SKlient::trenne() // trennt die Verbindung zum Klient
  261. {
  262. if (!sock)
  263. return 0;
  264. if (closesocket(sock) < 0) // trennen
  265. return 0;
  266. sock = 0;
  267. return 1;
  268. }
  269. // constant
  270. bool SKlient::hatNachricht(int zeit) const // Wartet eine Zeit Lang auf eine Nachricht
  271. {
  272. fd_set set;
  273. FD_ZERO(&set);
  274. FD_SET(sock, &set);
  275. timeval time = { zeit / 1000, zeit };
  276. return select(0, &set, 0, 0, &time) == 1;
  277. }
  278. unsigned short SKlient::getPort() const // gibt den Port zurück
  279. {
  280. return htons(clientAddr.sin_port);
  281. }
  282. const char* SKlient::getIp() const // gibt die Ip des Klients zurück
  283. {
  284. return inet_ntoa(clientAddr.sin_addr);
  285. }
  286. int pem_passwd_cb(char* buf, int size, int rwflag, void* userdata)
  287. {
  288. const char* passw = ((Text*)userdata)->getText();
  289. memcpy(buf, passw, MIN((unsigned int)size, strlen(passw) + 1));
  290. return (int)strlen(buf);
  291. }
  292. bool SSLErrorCheck(int result, SSL* ssl, const char* action)
  293. {
  294. if (result <= 0)
  295. {
  296. std::cout << "ERROR: '" << action << "' returned error code: " << SSL_get_error(ssl, result) << "\n";
  297. std::cout.flush();
  298. return 0;
  299. }
  300. return 1;
  301. }
  302. bool SSLErrorCheck(__int64 result, const char* action)
  303. {
  304. if (result <= 0)
  305. {
  306. unsigned long error = ERR_get_error();
  307. std::cout << "ERROR: '" << action << "' returned " << result << " error code: " << error << "(" << ERR_reason_error_string(error) << ")\n";
  308. std::cout.flush();
  309. return 0;
  310. }
  311. return 1;
  312. }
  313. bool SKlient::waitForNextMessage() const // wartet bis es etwas zu empfangen gibt
  314. {
  315. fd_set set;
  316. int rv = 0;
  317. struct timeval timeout;
  318. while (rv == 0 && sock)
  319. {
  320. FD_ZERO(&set); /* clear the set */
  321. FD_SET(sock, &set); /* add our file descriptor to the set */
  322. timeout.tv_sec = 10;
  323. timeout.tv_usec = 0;
  324. rv = select((int)sock + 1, &set, NULL, NULL, &timeout);
  325. if (rv == -1) return 0;
  326. }
  327. if (!sock) return 0;
  328. char c;
  329. int l = (int)recv(sock, &c, 1, MSG_WAITALL | MSG_PEEK);
  330. if (l <= 0)
  331. return 0; // Fehler
  332. return 1;
  333. }
  334. // Inhalt der SSLServer Klasse
  335. // Konstruktor
  336. SSLServer::SSLServer()
  337. : ReferenceCounter()
  338. {
  339. s = 0;
  340. const SSL_METHOD* method = TLS_server_method();
  341. ctx = SSL_CTX_new(method);
  342. SSLErrorCheck(SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION), "SSL_CTX_set_min_proto_version");
  343. SSLErrorCheck(SSL_CTX_set_max_proto_version(ctx, TLS1_3_VERSION), "SSL_CTX_set_max_proto_version");
  344. SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0);
  345. SSL_CTX_set_default_passwd_cb(ctx, pem_passwd_cb);
  346. passw = new Text();
  347. SSL_CTX_set_default_passwd_cb_userdata(ctx, passw);
  348. addr.sin_family = AF_INET;
  349. addr.sin_addr.s_addr = htonl(INADDR_ANY);
  350. klients = 0;
  351. }
  352. // Destruktor
  353. SSLServer::~SSLServer()
  354. {
  355. trenne();
  356. SSL_CTX_free(ctx);
  357. passw->release();
  358. #ifdef WIN32
  359. OPENSSL_thread_stop();
  360. #endif
  361. }
  362. // nicht constant
  363. // Setzt den Pfad zur Datei, in dem das Certifikat gespeichert ist
  364. bool SSLServer::setCertificateFile(const char* file)
  365. {
  366. return SSLErrorCheck(SSL_CTX_use_certificate_file(ctx, file, SSL_FILETYPE_PEM), "SSL_CTX_use_certificate_file");
  367. }
  368. // Setzt den Pfad zur Datei, in dem der private Schlüssel gespeichert ist
  369. bool SSLServer::setPrivateKeyFile(const char* file)
  370. {
  371. return SSLErrorCheck(SSL_CTX_use_PrivateKey_file(ctx, file, SSL_FILETYPE_PEM), "SSL_CTX_use_PrivateKey_file");
  372. }
  373. // setzt das passwort des private keys (muss vor setPrivateKeyFile aufgerufen werden)
  374. void SSLServer::setPrivateKeyPassword(const char* password)
  375. {
  376. passw->setText(password);
  377. }
  378. // Öffnet das Socket
  379. bool SSLServer::verbinde(unsigned short port, int warteschlangenLen)
  380. {
  381. addr.sin_port = htons(port);
  382. s = socket(AF_INET, SOCK_STREAM, 0);
  383. if (s < 0)
  384. {
  385. s = 0;
  386. return 0;
  387. }
  388. if (bind(s, (struct sockaddr*)&addr, sizeof(addr)) < 0)
  389. {
  390. trenne();
  391. return 0;
  392. }
  393. if (listen(s, warteschlangenLen) < 0)
  394. {
  395. trenne();
  396. return 0;
  397. }
  398. return 1;
  399. }
  400. // nimmt Klient an
  401. SSLSKlient* SSLServer::getKlient()
  402. {
  403. if (!s)
  404. return 0;
  405. int len = sizeof(addr);
  406. struct sockaddr_in addr;
  407. fd_set set;
  408. int rv = 0;
  409. struct timeval timeout;
  410. while (rv == 0 && s)
  411. {
  412. FD_ZERO(&set); /* clear the set */
  413. FD_SET(s, &set); /* add our file descriptor to the set */
  414. timeout.tv_sec = 10;
  415. timeout.tv_usec = 0;
  416. rv = select((int)s + 1, &set, NULL, NULL, &timeout);
  417. if (rv == -1) return 0;
  418. }
  419. if (!s) return 0;
  420. #ifdef WIN32
  421. SOCKET client = accept(s, (struct sockaddr*)&addr, &len);
  422. if (client == INVALID_SOCKET)
  423. {
  424. trenne();
  425. return 0;
  426. }
  427. #else
  428. SOCKET client = accept(s, (sockaddr*)&addr, (socklen_t*)&len); // Klient empfangen
  429. if (!client)
  430. {
  431. if (errno == ECONNABORTED || errno == EBADF)
  432. trenne();
  433. return 0;
  434. }
  435. #endif
  436. addr.sin_port = this->addr.sin_port;
  437. SSL* ssl = SSL_new(ctx);
  438. if (ssl == 0 && !SSLErrorCheck(0, "SSL_new"))
  439. {
  440. closesocket(client);
  441. return 0;
  442. }
  443. if (!SSLErrorCheck(SSL_set_fd(ssl, (int)client), ssl, "SSL_set_fd"))
  444. {
  445. SSL_free(ssl);
  446. closesocket(client);
  447. return 0;
  448. }
  449. if (!SSLErrorCheck(SSL_accept(ssl), ssl, "SSL_accept"))
  450. {
  451. SSL_free(ssl);
  452. closesocket(client);
  453. return 0;
  454. }
  455. klients++;
  456. return new SSLSKlient(addr, ssl, client);
  457. }
  458. // gibt die Anzahl der Klients zurück
  459. int SSLServer::getKlients(bool reset)
  460. {
  461. int ret = klients;
  462. if (reset)
  463. klients = 0;
  464. return ret;
  465. }
  466. // beendet den Server
  467. bool SSLServer::trenne()
  468. {
  469. if (!s)
  470. return 1;
  471. if (closesocket(s) < 0) // socket schließen
  472. return 0;
  473. s = 0;
  474. return 1;
  475. }
  476. // constant
  477. // gibt den Port zurück
  478. unsigned short SSLServer::getPort() const
  479. {
  480. return htons(addr.sin_port);
  481. }
  482. // giebt 1 zurück, falls der Server verbunden ist
  483. bool SSLServer::isConnected() const
  484. {
  485. return s != 0;
  486. }
  487. // Inhalt der SSLSKlient Klasse
  488. // Konstruktor
  489. SSLSKlient::SSLSKlient(sockaddr_in client, SSL* ssl, SOCKET s)
  490. : ReferenceCounter()
  491. {
  492. this->s = s;
  493. clientAddr = client;
  494. this->ssl = ssl;
  495. downStreamBytes = 0;
  496. upStreamBytes = 0;
  497. }
  498. // Destruktor
  499. SSLSKlient::~SSLSKlient()
  500. {
  501. trenne();
  502. #ifdef WIN32
  503. OPENSSL_thread_stop();
  504. #endif
  505. }
  506. // nicht constant
  507. void SSLSKlient::setEmpfangTimeout(int miliseconds) // Setzt ein timeout fürs empfangen von daten
  508. {
  509. #ifdef WIN32
  510. DWORD timeout = miliseconds;
  511. setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof timeout);
  512. #else
  513. struct timeval tv;
  514. tv.tv_sec = miliseconds / 1000;
  515. tv.tv_usec = (miliseconds % 1000) * 1000;
  516. setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof tv);
  517. #endif
  518. }
  519. bool SSLSKlient::sende(const char* nachricht, int len) // sendet zum Klient
  520. {
  521. if (!ssl)
  522. return 0;
  523. int ll = 0;
  524. while (len > 0)
  525. {
  526. int l = SSL_write(ssl, nachricht + ll, len);
  527. if (l <= 0)
  528. return 0; // Fehler
  529. len -= l;
  530. ll += l;
  531. }
  532. upStreamBytes += ll;
  533. return 1;
  534. }
  535. bool SSLSKlient::getNachricht(char* nachricht, int len) // empfängt Nachricht von Klient
  536. {
  537. if (!ssl)
  538. return 0;
  539. int ll = 0;
  540. while (len > 0)
  541. {
  542. int l = (int)SSL_read(ssl, nachricht + ll, len);
  543. if (l <= 0)
  544. return 0; // Fehler
  545. len -= l;
  546. ll += l;
  547. }
  548. downStreamBytes += ll;
  549. return 1;
  550. }
  551. int SSLSKlient::getDownloadBytes(bool reset) // gibt die anzahl von empfangen bytes zurück
  552. {
  553. int ret = downStreamBytes;
  554. if (reset)
  555. downStreamBytes = 0;
  556. return ret;
  557. }
  558. int SSLSKlient::getUploadBytes(bool reset) // gibt die anzahl von versendeter bytes zurück
  559. {
  560. int ret = upStreamBytes;
  561. if (reset)
  562. upStreamBytes = 0;
  563. return ret;
  564. }
  565. bool SSLSKlient::trenne() // trennt die Verbindung zum Klient
  566. {
  567. if (!ssl)
  568. return 0;
  569. SSL_free(ssl);
  570. if (closesocket(s) < 0) // trennen
  571. return 0;
  572. ssl = 0;
  573. s = 0;
  574. return 1;
  575. }
  576. // constant
  577. bool SSLSKlient::hatNachricht(int zeit) const // Wartet eine Zeit Lang auf eine Nachricht
  578. {
  579. fd_set set;
  580. FD_ZERO(&set);
  581. FD_SET(SSL_get_rfd(ssl), &set);
  582. timeval time = { zeit / 1000, zeit };
  583. return SSL_pending(ssl) > 0 || select(0, &set, 0, 0, &time) == 1;
  584. }
  585. unsigned short SSLSKlient::getPort() const // gibt den Port zurück
  586. {
  587. return htons(clientAddr.sin_port);
  588. }
  589. const char* SSLSKlient::getIp() const // gibt die Ip des Klients zurück
  590. {
  591. return inet_ntoa(clientAddr.sin_addr);
  592. }