-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathPKG-INFO
230 lines (176 loc) · 8.32 KB
/
PKG-INFO
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
Metadata-Version: 2.1
Name: RC6Encryption
Version: 1.0.1
Summary: This package implements the RC6 encryption.
Home-page: https://github.com/mauricelambert/RC6Encryption
Download-URL: https://mauricelambert.github.io/info/python/security/RC6Encryption.pyz
Author: Maurice Lambert
Author-email: Maurice Lambert <mauricelambert434@gmail.com>
Maintainer: Maurice Lambert
Maintainer-email: Maurice Lambert <mauricelambert434@gmail.com>
License: GPL-3.0 License
Project-URL: Github, https://github.com/mauricelambert/RC6Encryption
Project-URL: Documentation, https://mauricelambert.github.io/info/python/security/RC6Encryption.html
Project-URL: Python Executable, https://mauricelambert.github.io/info/python/security/RC6Encryption.pyz
Project-URL: Windows Executable, https://mauricelambert.github.io/info/python/security/RC6Encryption.exe
Keywords: RC6,Encryption,Cipher,PurePython
Platform: Windows
Platform: Linux
Platform: MacOS
Classifier: Topic :: Security
Classifier: Environment :: Console
Classifier: Operating System :: MacOS
Classifier: Natural Language :: English
Classifier: Programming Language :: Python
Classifier: Intended Audience :: Developers
Classifier: Topic :: Security :: Cryptography
Classifier: Operating System :: POSIX :: Linux
Classifier: Programming Language :: Python :: 3.9
Classifier: Operating System :: Microsoft :: Windows
Classifier: Intended Audience :: System Administrators
Classifier: Development Status :: 5 - Production/Stable
Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
Requires-Python: >=3.8
Description-Content-Type: text/markdown
License-File: LICENSE.txt
# RC6Encryption
## Description
This pure python package implements the RC6 encryption (ECB and CBC encryption mode).
> All encryption and decryption mode are tested, i compare the result with https://www.lddgo.net/en/encrypt/rc6 API.
>> The ECB mode is not recommended, it's the basic encryption for block cipher, you should always use CBC encryption for data greater than 16 bytes.
## Requirements
This package require:
- python3
- python3 Standard Library
## Installation
### Pip
```bash
python3 -m pip install RC6Encryption
```
### Git
```bash
git clone "https://github.com/mauricelambert/RC6Encryption.git"
cd "RC6Encryption"
python3 -m pip install .
```
### Wget
```bash
wget https://github.com/mauricelambert/RC6Encryption/archive/refs/heads/main.zip
unzip main.zip
cd RC6Encryption-main
python3 -m pip install .
```
### cURL
```bash
curl -O https://github.com/mauricelambert/RC6Encryption/archive/refs/heads/main.zip
unzip main.zip
cd RC6Encryption-main
python3 -m pip install .
```
## Usages
### Recommended options
```bash
rc6 [key] -m CBC -6 -o [secrets.cipher] -i [secrets.file] # encryption
rc6 [key] -m CBC -n base64 -i [secrets.cipher] -o [decipher.file] -d # decryption
```
### Command line
#### Module
```bash
python3 -m RC6Encryption rc6key -s secrets
```
#### Python executable
```bash
python3 RC6Encryption.pyz rc6key -s secrets
```
#### Command
##### Basic
```bash
rc6 rc6key -s secrets # encrypt "secrets" with rc6key sha256 as key
```
##### Advanced
```bash
rc6 rc6key -r 12 -l 5 -w 32 -s secrets # encrypt "secrets" with rc6key sha256 as key (rounds=12, wbit=32, lgw=5) in ECB mode
echo secrets| rc6 rc6key --no-sha256 -i # encrypt "secrets\n" with key and PKCS 5/7 padding in ECB mode
rc6 rc6key -m CBC -I IVTEST -i secrets.txt # encrypt secrets.txt file content with rc6key sha256 as key and CBC mode and IVTEST as IV
rc6 rc6key -o encrypt.rc6 -s secrets -m CBC # encrypt "secrets" with rc6key sha256 as key, IVTEST as IV and redirect the output to the encrypt.rc6 file using CBC encryption mode and random IV
rc6 rc6key -i encrypt.rc6 -d -m CBC # decrypt encrypt.rc6 with rc6key sha256 as key using CBC encryption mode
## INPUT ENCODING
rc6 rc6key -n base64 -s c2VjcmV0cw== # encrypt "secrets" with rc6key sha256 as key ("c2VjcmV0cw==" = base64("secrets"))
## OUTPUT ENCODING
rc6 rc6key -s secrets -8 # encrypt "secrets" with rc6key sha256 as key, base85-encoded output
rc6 rc6key -s secrets -6 # encrypt "secrets" with rc6key sha256 as key, base64-encoded output
rc6 rc6key -s secrets -3 # encrypt "secrets" with rc6key sha256 as key, base30-encoded output
rc6 rc6key -s secrets -1 # encrypt "secrets" with rc6key sha256 as key, base16-encoded output
rc6 rc6key -s secrets -u # encrypt "secrets" with rc6key sha256 as key, uu-encoded output
```
### Python script
#### RC6 encryption using CBC (recommended)
```python
from RC6Encryption import RC6Encryption
rc6 = RC6Encryption(b'abcdefghijklm')
iv, encrypt = rc6.data_encryption_CBC(b'abcdefghijklmnopabcdefghijklmnopabcdefghijklm') # Random IV
plaintext = rc6.data_decryption_CBC(encrypt, iv)
iv, encrypt = rc6.data_encryption_CBC(b'abcdefghijklmnopabcdefghijklmnopabcdefghijklm', b'IVTEST') # Generate your IV, be careful, an IV with size less than 16 bytes is not recommended
plaintext = rc6.data_decryption_CBC(encrypt, iv)
```
#### RC6 encryption using ECB (not recommended)
```python
from RC6Encryption import RC6Encryption
rc6 = RC6Encryption(b'abcdefghijklm')
encrypt = rc6.data_encryption_ECB(b'abcdefghijklmnopabcdefghijklmnopabcdefghijklm')
plaintext = rc6.data_decryption_ECB(encrypt)
```
#### Low level API
```python
from RC6Encryption import RC6Encryption
from hashlib import sha256
rc6 = RC6Encryption(sha256(b'abcdefghijklmnop').digest())
cipher = rc6.blocks_to_data(rc6.encrypt(b'abcdefghijklmnop'))
decipher = rc6.blocks_to_data(rc6.decrypt(cipher))
```
## Links
- [Pypi](https://pypi.org/project/RC6Encryption/)
- [Github](https://github.com/mauricelambert/RC6Encryption/)
- [Documentation](https://mauricelambert.github.io/info/python/security/RC6Encryption.html)
- [Executable](https://mauricelambert.github.io/info/python/security/RC6Encryption.pyz)
- [Python Windows executable](https://mauricelambert.github.io/info/python/security/RC6Encryption.exe)
## Help
```text
usage: RC6Encryption.py [-h] [--mode {CBC,ECB}] [--decryption] (--input-file [INPUT_FILE] | --input-string INPUT_STRING) [--output-file OUTPUT_FILE]
[--base85 | --base64 | --base32 | --base16 | --output-encoding {base32,base16,base64,base85}]
[--input-encoding {base32,base16,base64,base85}] [--rounds ROUNDS] [--w-bit W_BIT] [--iv IV] [--lgw LGW] [--sha256 | --no-sha256]
key
This script performs RC6 encryption.
positional arguments:
key Encryption key.
options:
-h, --help show this help message and exit
--mode {CBC,ECB}, -m {CBC,ECB}
Ecryption mode, for CBC encryption IV is write on the first 16 bytes of the encrypted data.
--decryption, -d Data decryption.
--input-file [INPUT_FILE], --i-file [INPUT_FILE], -i [INPUT_FILE]
The file to be encrypted.
--input-string INPUT_STRING, --string INPUT_STRING, -s INPUT_STRING
The string to be encrypted.
--output-file OUTPUT_FILE, --o-file OUTPUT_FILE, -o OUTPUT_FILE
The output file.
--base85, --85, -8 Base85 encoding as output format
--base64, --64, -6 Base64 encoding as output format
--base32, --32, -3 Base32 encoding as output format
--base16, --16, -1 Base16 encoding as output format
--output-encoding {base32,base16,base64,base85}, --o-encoding {base32,base16,base64,base85}, -e {base32,base16,base64,base85}
Output encoding.
--input-encoding {base32,base16,base64,base85}, --i-encoding {base32,base16,base64,base85}, -n {base32,base16,base64,base85}
Input encoding.
--rounds ROUNDS, -r ROUNDS
RC6 rounds
--w-bit W_BIT, -b W_BIT
RC6 w-bit
--iv IV, -I IV IV for CBC mode only, for decryption if IV is not set the 16 first bytes are used instead.
--lgw LGW, -l LGW RC6 lgw
--sha256, --no-sha256
Use the sha256 hash of the key as the key.
```
## Licence
Licensed under the [GPL, version 3](https://www.gnu.org/licenses/).