cipher/cipher.cpp at main · valkosch/cipher · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include "cipher.h"
#include "string.h"
#include <cstdint>
#include <iostream>
XOR::XOR(const String& key): key(key){}
String XOR::decode(const Vector<uint8_t>& ciphertext) const{
  String res;
  size_t key_len = key.getLength();
  size_t text_len = ciphertext.size();
  char c;
  for(size_t x = 0; x<text_len; ++x){
    c = ciphertext[x]^key[x%key_len];
    res += c;
  }
  return res;
}
Vector<uint8_t> XOR::encode(const String& plaintext)const{
  Vector<uint8_t> res(plaintext.getLength());
  size_t key_len = key.getLength();
  size_t text_len = plaintext.getLength();
  for(size_t x = 0; x<text_len; ++x){
    res[x] = plaintext[x]^key[x%key_len];
  }
  return res;
}

Vigenere::Vigenere(const String& _key){
  if(!_key.isalpha()) throw std::invalid_argument("Csak alfanumerikus kulccsal működik!");
  key = _key;
  key.toUpper();
}
Vector<uint8_t> Vigenere::encode(const String& plaintext) const{
  if(!plaintext.isalpha()) throw std::invalid_argument("Csak alfanumerikus szöveggel működik!");
  String plainUp = plaintext;
  Vector<uint8_t> res(plaintext.getLength());
  size_t key_len = key.getLength();
  size_t text_len = plaintext.getLength();
  plainUp.toUpper();
  for(size_t x = 0; x<text_len; ++x){
    res[x] = 'A' + (plainUp[x]-'A' + key[x%key_len]-'A')%26;
  }
  return res;
}
String Vigenere::decode(const Vector<uint8_t>& ciphertext) const{
  String res;
  size_t key_len = key.getLength();
  size_t text_len = ciphertext.size();
  char c;
  for(size_t x = 0; x<text_len; ++x){
    c = 'A' + (ciphertext[x]-'A' + (26 - (key[x%key_len]-'A')))%26;
    res += c;
  }
  return res;
}
Bifid::Bifid(const String& _key){
  if(!_key.isalpha()) throw std::invalid_argument("Csak alfanumerikus kulccsal működik!");
  String tmp = _key;
  tmp.toUpper();
  String used('J');
  int x = 0;
  int y = 0;
  int len = _key.getLength();
  for(size_t i = 0; i < 5; ++i){
    for(size_t j = 0; j < 5; ++j){
        while(y < len && used == tmp[y]) y++;
        if(y < len){
            key[i][j] = tmp[y];
            used += tmp[y];
            y++;
         }
        else{
            while(used == ('A' + x)) x++;
            key[i][j] = 'A' + x;
            used += 'A' + x;
            x++;
        }
        }
    }
 }
Bifid::Point Bifid::find_it(char c) const{
  for(size_t i = 0; i < 5; ++i){
    for(size_t j = 0; j < 5; ++j){
      if(key[i][j] == c) return Point(j,i);
    }
  }
  return Point(5,5);
}
Vector<uint8_t> Bifid::encode(const String& plaintext) const{
  if(!plaintext.isalpha()) throw std::invalid_argument("Csak alfanumerikus szöveggel működik!");
  String plainUp = plaintext;
  Vector<uint8_t> res(plaintext.getLength());
  size_t text_len = plaintext.getLength();
  plainUp.toUpper();
  Vector<size_t> idx(text_len*2);
  Point tmp;
  for(size_t i = 0; i < text_len; ++i){
    tmp = find_it(plainUp[i]);
    idx[i] = tmp.y;
    idx[text_len+i] = tmp.x;
  }
  for(size_t i = 0; i < text_len; ++i){
    res[i] = key[idx[i*2]][idx[i*2+1]];
  }
  return res;
}
String Bifid::decode(const Vector<uint8_t>& ciphertext) const{
  String res;
  size_t text_len = ciphertext.size();
  char c;
  Vector<size_t> idx(text_len*2);
  Point tmp;
  for(size_t i = 0; i < text_len; ++i){
    tmp = find_it(ciphertext[i]);
    idx[i*2] = tmp.y;
    idx[i*2+1] = tmp.x;
  }
  for(size_t i = 0; i < text_len; ++i){
    c = key[idx[i]][idx[text_len+i]];
    res += c;
  }
  return res;
}