verschlüsselungsprogramm

  • C++

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • verschlüsselungsprogramm

    Hallo!

    Ich habe nachfolgendes Verschlüsselungsprogramm geschrieben und wollte mal wissen, was ihr davon haltet:

    C-Quellcode

    1. #include <iostream>
    2. #include <fstream>
    3. #include <stdio.h>
    4. using namespace std;
    5. FILE *Datei1;
    6. char Einlesepuffer[2];
    7. char zeichen;
    8. int Zeichenanzahl = 0;
    9. char *pallezeichen = 0;
    10. int i = 0;
    11. int k = 0;
    12. int main() {
    13. ifstream datei;
    14. string dateipfad = "C:\\text.txt";
    15. Datei1 = fopen("c:\\text.txt","r");
    16. if(!Datei1)
    17. {
    18. cout << "Fehler beim Lesen";
    19. cin;
    20. return 0;
    21. }
    22. while(feof(Datei1) == 0)
    23. {
    24. fgets(Einlesepuffer,2,Datei1);
    25. Zeichenanzahl++;
    26. }
    27. fclose(Datei1);
    28. Zeichenanzahl--;
    29. pallezeichen = new char[Zeichenanzahl];
    30. datei.open(dateipfad.c_str(), ios_base::in);
    31. ofstream neuedatei;
    32. string neuer_dateiname = "C:\\neuertext.txt";
    33. neuedatei.open(neuer_dateiname.c_str(), ios_base::out);
    34. if(!neuedatei)
    35. {
    36. cout << "Fehler beim Oeffnen";
    37. cin;
    38. return 0;
    39. }
    40. for(int z=0; z<Zeichenanzahl; z++)
    41. {
    42. if(!datei.eof())
    43. {
    44. datei.get(zeichen);
    45. pallezeichen[z] = zeichen;
    46. }
    47. }
    48. datei.close();
    49. /********************************************************************************/
    50. /* Hauptteil */
    51. int Eingabe = 0;
    52. cout << "Moechten sie\n entschluesseln (1)\n verschluesseln (2) ?\n";
    53. while(1)
    54. {
    55. cin >> Eingabe;
    56. int i=0;
    57. int k=0;
    58. switch(Eingabe)
    59. {
    60. /*ENTSCHLUESSELUNGSTEIL*/
    61. case 1:
    62. while(i < Zeichenanzahl)
    63. {
    64. switch(pallezeichen[i])
    65. {
    66. /*KLEINES ALPHABET*/
    67. case '&':
    68. pallezeichen[i] = 'a';
    69. break;
    70. case '#':
    71. pallezeichen[i] = 'b';
    72. break;
    73. case '=':
    74. pallezeichen[i] = 'c';
    75. break;
    76. case '§':
    77. pallezeichen[i] = 'd';
    78. break;
    79. case ' ':
    80. pallezeichen[i] = 'e';
    81. break;
    82. case '$':
    83. pallezeichen[i] = 'f';
    84. break;
    85. case '%':
    86. pallezeichen[i] = 'g';
    87. break;
    88. case '}':
    89. pallezeichen[i] = 'h';
    90. break;
    91. case '{':
    92. pallezeichen[i] = 'i';
    93. break;
    94. case ')':
    95. pallezeichen[i] = 'j';
    96. break;
    97. case '(':
    98. pallezeichen[i] = 'k';
    99. break;
    100. case ']':
    101. pallezeichen[i] = 'l';
    102. break;
    103. case '[':
    104. pallezeichen[i] = 'm';
    105. break;
    106. case '!':
    107. pallezeichen[i] = 'n';
    108. break;
    109. case '?':
    110. pallezeichen[i] = 'o';
    111. break;
    112. case '.':
    113. pallezeichen[i] = 'p';
    114. break;
    115. case '\\':
    116. pallezeichen[i] = 'q';
    117. break;
    118. case '/':
    119. pallezeichen[i] = 'r';
    120. break;
    121. case '*':
    122. pallezeichen[i] = 's';
    123. break;
    124. case '+':
    125. pallezeichen[i] = 't';
    126. break;
    127. case '-':
    128. pallezeichen[i] = 'u';
    129. break;
    130. case '_':
    131. pallezeichen[i] = 'v';
    132. break;
    133. case '0':
    134. pallezeichen[i] = 'w';
    135. break;
    136. case '9':
    137. pallezeichen[i] = 'x';
    138. break;
    139. case '8':
    140. pallezeichen[i] = 'y';
    141. break;
    142. case '7':
    143. pallezeichen[i] = 'z';
    144. break;
    145. /*GROSSES ALPHABET*/
    146. case '6':
    147. pallezeichen[i] = 'A';
    148. break;
    149. case '5':
    150. pallezeichen[i] = 'B';
    151. break;
    152. case '4':
    153. pallezeichen[i] = 'C';
    154. break;
    155. case '3':
    156. pallezeichen[i] = 'D';
    157. break;
    158. case '2':
    159. pallezeichen[i] = 'E';
    160. break;
    161. case '1':
    162. pallezeichen[i] = 'F';
    163. break;
    164. case 'Z':
    165. pallezeichen[i] = 'G';
    166. break;
    167. case 'Y':
    168. pallezeichen[i] = 'H';
    169. break;
    170. case 'X':
    171. pallezeichen[i] = 'I';
    172. break;
    173. case 'W':
    174. pallezeichen[i] = 'J';
    175. break;
    176. case 'V':
    177. pallezeichen[i] = 'K';
    178. break;
    179. case 'U':
    180. pallezeichen[i] = 'L';
    181. break;
    182. case 'T':
    183. pallezeichen[i] = 'M';
    184. break;
    185. case 'S':
    186. pallezeichen[i] = 'N';
    187. break;
    188. case 'R':
    189. pallezeichen[i] = 'O';
    190. break;
    191. case 'Q':
    192. pallezeichen[i] = 'P';
    193. break;
    194. case 'P':
    195. pallezeichen[i] = 'Q';
    196. break;
    197. case 'O':
    198. pallezeichen[i] = 'R';
    199. break;
    200. case 'N':
    201. pallezeichen[i] = 'S';
    202. break;
    203. case 'M':
    204. pallezeichen[i] = 'T';
    205. break;
    206. case 'L':
    207. pallezeichen[i] = 'U';
    208. break;
    209. case 'K':
    210. pallezeichen[i] = 'V';
    211. break;
    212. case 'J':
    213. pallezeichen[i] = 'W';
    214. break;
    215. case 'I':
    216. pallezeichen[i] = 'X';
    217. break;
    218. case 'H':
    219. pallezeichen[i] = 'Y';
    220. break;
    221. case 'G':
    222. pallezeichen[i] = 'Z';
    223. break;
    224. /*ZAHLEN*/
    225. case 'F':
    226. pallezeichen[i] = '1';
    227. break;
    228. case 'E':
    229. pallezeichen[i] = '2';
    230. break;
    231. case 'D':
    232. pallezeichen[i] = '3';
    233. break;
    234. case 'C':
    235. pallezeichen[i] = '4';
    236. break;
    237. case 'B':
    238. pallezeichen[i] = '5';
    239. break;
    240. case 'A':
    241. pallezeichen[i] = '6';
    242. break;
    243. case 'z':
    244. pallezeichen[i] = '7';
    245. break;
    246. case 'y':
    247. pallezeichen[i] = '8';
    248. break;
    249. case 'x':
    250. pallezeichen[i] = '9';
    251. break;
    252. case 'w':
    253. pallezeichen[i] = '0';
    254. break;
    255. /*SONDERZEICHEN*/
    256. case 'i':
    257. pallezeichen[i] = ' ';
    258. break;
    259. case 'v':
    260. pallezeichen[i] = '_';
    261. break;
    262. case 'u':
    263. pallezeichen[i] = '+';
    264. break;
    265. case 't':
    266. pallezeichen[i] = '-';
    267. break;
    268. case 'p':
    269. pallezeichen[i] = '.';
    270. break;
    271. case 'o':
    272. pallezeichen[i] = '?';
    273. break;
    274. case 'n':
    275. pallezeichen[i] = '!';
    276. break;
    277. case 'c':
    278. pallezeichen[i] = '=';
    279. break;
    280. case 'b':
    281. pallezeichen[i] = '#';
    282. break;
    283. case 's':
    284. pallezeichen[i] = '*';
    285. break;
    286. case 'h':
    287. pallezeichen[i] = '{';
    288. break;
    289. case 'g':
    290. pallezeichen[i] = '}';
    291. break;
    292. case 'm':
    293. pallezeichen[i] = '[';
    294. break;
    295. case 'l':
    296. pallezeichen[i] = ']';
    297. break;
    298. case 'k':
    299. pallezeichen[i] = '(';
    300. break;
    301. case 'j':
    302. pallezeichen[i] = ')';
    303. break;
    304. case 'r':
    305. pallezeichen[i] = '/';
    306. break;
    307. case 'q':
    308. pallezeichen[i] = '\\';
    309. break;
    310. case 'a':
    311. pallezeichen[i] = '&';
    312. break;
    313. case 'f':
    314. pallezeichen[i] = '%';
    315. break;
    316. case 'e':
    317. pallezeichen[i] = '$';
    318. break;
    319. case 'd':
    320. pallezeichen[i] = '§';
    321. break;
    322. }
    323. i++;
    324. }
    325. break;
    326. /*VERSCLUESSELUNGSTEIL*/
    327. case 2:
    328. while(k < Zeichenanzahl)
    329. {
    330. switch(pallezeichen[k])
    331. {
    332. /*KLEINES ALPHABET*/
    333. case 'a':
    334. pallezeichen[k] = '&';
    335. break;
    336. case 'b':
    337. pallezeichen[k] = '#';
    338. break;
    339. case 'c':
    340. pallezeichen[k] = '=';
    341. break;
    342. case 'd':
    343. pallezeichen[k] = '§';
    344. break;
    345. case 'e':
    346. pallezeichen[k] = ' ';
    347. break;
    348. case 'f':
    349. pallezeichen[k] = '$';
    350. break;
    351. case 'g':
    352. pallezeichen[k] = '%';
    353. break;
    354. case 'h':
    355. pallezeichen[k] = '}';
    356. break;
    357. case 'i':
    358. pallezeichen[k] = '{';
    359. break;
    360. case 'j':
    361. pallezeichen[k] = ')';
    362. break;
    363. case 'k':
    364. pallezeichen[k] = '(';
    365. break;
    366. case 'l':
    367. pallezeichen[k] = ']';
    368. break;
    369. case 'm':
    370. pallezeichen[k] = '[';
    371. break;
    372. case 'n':
    373. pallezeichen[k] = '!';
    374. break;
    375. case 'o':
    376. pallezeichen[k] = '?';
    377. break;
    378. case 'p':
    379. pallezeichen[k] = '.';
    380. break;
    381. case 'q':
    382. pallezeichen[k] = '\\';
    383. break;
    384. case 'r':
    385. pallezeichen[k] = '/';
    386. break;
    387. case 's':
    388. pallezeichen[k] = '*';
    389. break;
    390. case 't':
    391. pallezeichen[k] = '+';
    392. break;
    393. case 'u':
    394. pallezeichen[k] = '-';
    395. break;
    396. case 'v':
    397. pallezeichen[k] = '_';
    398. break;
    399. case 'w':
    400. pallezeichen[k] = '0';
    401. break;
    402. case 'x':
    403. pallezeichen[k] = '9';
    404. break;
    405. case 'y':
    406. pallezeichen[k] = '8';
    407. break;
    408. case 'z':
    409. pallezeichen[k] = '7';
    410. break;
    411. /*GROSSES ALPHABET*/
    412. case 'A':
    413. pallezeichen[k] = '6';
    414. break;
    415. case 'B':
    416. pallezeichen[k] = '5';
    417. break;
    418. case 'C':
    419. pallezeichen[k] = '4';
    420. break;
    421. case 'D':
    422. pallezeichen[k] = '3';
    423. break;
    424. case 'E':
    425. pallezeichen[k] = '2';
    426. break;
    427. case 'F':
    428. pallezeichen[k] = '1';
    429. break;
    430. case 'G':
    431. pallezeichen[k] = 'Z';
    432. break;
    433. case 'H':
    434. pallezeichen[k] = 'Y';
    435. break;
    436. case 'I':
    437. pallezeichen[k] = 'X';
    438. break;
    439. case 'J':
    440. pallezeichen[k] = 'W';
    441. break;
    442. case 'K':
    443. pallezeichen[k] = 'V';
    444. break;
    445. case 'L':
    446. pallezeichen[k] = 'U';
    447. break;
    448. case 'M':
    449. pallezeichen[k] = 'T';
    450. break;
    451. case 'N':
    452. pallezeichen[k] = 'S';
    453. break;
    454. case 'O':
    455. pallezeichen[k] = 'R';
    456. break;
    457. case 'P':
    458. pallezeichen[k] = 'Q';
    459. break;
    460. case 'Q':
    461. pallezeichen[k] = 'P';
    462. break;
    463. case 'R':
    464. pallezeichen[k] = 'O';
    465. break;
    466. case 'S':
    467. pallezeichen[k] = 'N';
    468. break;
    469. case 'T':
    470. pallezeichen[k] = 'M';
    471. break;
    472. case 'U':
    473. pallezeichen[k] = 'L';
    474. break;
    475. case 'V':
    476. pallezeichen[k] = 'K';
    477. break;
    478. case 'W':
    479. pallezeichen[k] = 'J';
    480. break;
    481. case 'X':
    482. pallezeichen[k] = 'I';
    483. break;
    484. case 'Y':
    485. pallezeichen[k] = 'H';
    486. break;
    487. case 'Z':
    488. pallezeichen[k] = 'G';
    489. break;
    490. /*ZAHLEN*/
    491. case '1':
    492. pallezeichen[k] = 'F';
    493. break;
    494. case '2':
    495. pallezeichen[k] = 'E';
    496. break;
    497. case '3':
    498. pallezeichen[k] = 'D';
    499. break;
    500. case '4':
    501. pallezeichen[k] = 'C';
    502. break;
    503. case '5':
    504. pallezeichen[k] = 'B';
    505. break;
    506. case '6':
    507. pallezeichen[k] = 'A';
    508. break;
    509. case '7':
    510. pallezeichen[k] = 'z';
    511. break;
    512. case '8':
    513. pallezeichen[k] = 'y';
    514. break;
    515. case '9':
    516. pallezeichen[k] = 'x';
    517. break;
    518. case '0':
    519. pallezeichen[k] = 'w';
    520. break;
    521. /*SONDERZEICHEN*/
    522. case ' ':
    523. pallezeichen[k] = 'i';
    524. break;
    525. case '_':
    526. pallezeichen[k] = 'v';
    527. break;
    528. case '+':
    529. pallezeichen[k] = 'u';
    530. break;
    531. case '-':
    532. pallezeichen[k] = 't';
    533. break;
    534. case '.':
    535. pallezeichen[k] = 'p';
    536. break;
    537. case '?':
    538. pallezeichen[k] = 'o';
    539. break;
    540. case '!':
    541. pallezeichen[k] = 'n';
    542. break;
    543. case '=':
    544. pallezeichen[k] = 'c';
    545. break;
    546. case '#':
    547. pallezeichen[k] = 'b';
    548. break;
    549. case '*':
    550. pallezeichen[k] = 's';
    551. break;
    552. case '{':
    553. pallezeichen[k] = 'h';
    554. break;
    555. case '}':
    556. pallezeichen[k] = 'g';
    557. break;
    558. case '[':
    559. pallezeichen[k] = 'm';
    560. break;
    561. case ']':
    562. pallezeichen[k] = 'l';
    563. break;
    564. case '(':
    565. pallezeichen[k] = 'k';
    566. break;
    567. case ')':
    568. pallezeichen[k] = 'j';
    569. break;
    570. case '/':
    571. pallezeichen[k] = 'r';
    572. break;
    573. case '\\':
    574. pallezeichen[k] = 'q';
    575. break;
    576. case '&':
    577. pallezeichen[k] = 'a';
    578. break;
    579. case '%':
    580. pallezeichen[k] = 'f';
    581. break;
    582. case '$':
    583. pallezeichen[k] = 'e';
    584. break;
    585. case '§':
    586. pallezeichen[k] = 'd';
    587. break;
    588. }
    589. k++;
    590. }
    591. break;
    592. default:
    593. cout << "Ungueltig! Geben Sie Ihre Wahl nocheinmal an!";
    594. break;
    595. }
    596. if(Eingabe == 1 || Eingabe == 2)
    597. {
    598. break;
    599. }
    600. }
    601. /* Ende Hauptteil */
    602. /********************************************************************************/
    603. neuedatei << pallezeichen;
    604. neuedatei.close();
    605. delete[] pallezeichen;
    606. return 0;
    607. }
    Alles anzeigen


    Anm: Das Programm liest aus der Datei "C:\text.txt" und speichert in "C:\neuertext.txt" ab
  • Das ist ja so eine Art Caesar Code. Wie schon gesagt, ziemlich einfach zu knacken^^
    Außerdem ist das ganze ziemlcih umständlich geschrieben. man könnte den zu verschlüsselnden Buchstaben so behandeln:

    Quellcode

    1. char buchstabe=a; //der aktuelle Buchstabe "a" wird in der Variable Buchstabe gespeichert
    2. int i=buchstabe; //ein int wird auf den wert des chars buchstabe gesetzt. Ja, das geht :)
    3. i = i+5; //mit dem Buchstaben wird nun gerechnet
    4. buchstabe=i; //der char buchstabe wird nun auf den wert i gesetzt, ist also nun um 5 "größer"
    5. cout<<buchstabe<<endl; //ergibt "f", weil f 5 "größer" als a ist


    das ist eigentlich keine Verschlüsselung, aber man kann sie ja noch beliebig verändern, z.B. jedes 2. mal statt 5 zu "i" zu addieren "7" zu subtrahieren.
    Deiner Phantasie sind keine grenzen gesetzt :)

    du kannst dir mit einem einfachen programm eine Tabelle ausgeben lassen, welcher buchstabe zur welcher zahl gehört
    [COLOR="Green"]"A dream you dream alone is only a dream. A dream you dream together is reality"[/color]

    John Lennon

    [SIZE=1],,,[/SIZE][SIZE=1]*&#801;&#844;l&#801;*,,,,,,,,,,&#801;&#801; &#801;&#820;&#305;&#820;&#820;&#801; ,,,,,,,,,*&#801;&#844;l&#801;*,,,,,,,,,,*&#801;&#844;l&#801;*&#801;&#801; &#801;&#820;&#305;&#820;&#820;&#801; &#801;&#801;&#865;|&#818;&#865;&#818;&#865;&#818;&#865; &#818;&#9643;&#865;&#818; &#818;&#865;&#818;&#865;&#818;&#960;&#818;&#865;&#818;&#865; &#818;&#865;&#818;&#9643;&#818;&#865;&#818;&#865; &#818;|&#801;&#801;&#801; &#801; &#801;&#820;&#305;&#820;&#801;&#801; *&#801;&#844;l&#801;*_,,,,,,,,&#801;&#801; &#801;&#820;&#305;&#820;&#820;&#801; ,,,,,,,,*&#801;&#844;l&#801;*,,[/SIZE][SIZE=1],,,[/SIZE][SIZE=1],,,,,,&#801;&#801; &#801;&#820;&#305;&#820;&#820;&#801; ,[/SIZE][SIZE=1],,[/SIZE]
    [SIZE="1"][COLOR="Purple"]Up 1[/color][/SIZE] [SIZE="1"] [COLOR="Olive"]Up 2_The_Beatles_Red_Album[/color][/SIZE]
  • vielen dank für den tip Ralph Peter!
    den trick mit buchstaben zu "rechnen" kannte ich noch nicht, aber wie so oft fängt man zuerst mit spaghetti-code an, bis es läuft und anschließend optimiert man ihn ;)

    ich wollte erst einmal sehen, ob ich die "einfache" variante hinbekomme, denn ich habe mir vorgenommen, das programm auf binärer-verschlüsselung und jeden dateityp umzubauen.
    das wird harte arbeit...