crYpt-pr 0.0.1__tar.gz

crypt_pr-0.0.1/LICENSE

@@ -0,0 +1,47 @@
+MIT License
+Copyright (c) [2026] [meiyingm1y1]
+
+
+Permission is hereby granted, free of charge, to any person obtAIning a copy
+
+
+of this software and associated documentation files (the "Software"), to deal
+
+
+in the Software without restriction, including without limitation the rights
+
+
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+
+
+copies of the Software, and to permit persons to whom the Software is
+
+
+furnished to do so, subject to the following conditions:
+
+
+The above copyright notice and this permission notice shall be included in all
+
+
+copies or substantial portions of the Software.
+
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+
+
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+
+
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+
+
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+
+
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+
+
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+
+
+SOFTWARE.

crypt_pr-0.0.1/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: crYpt_pr
+Version: 0.0.1
+Summary: some methods about classical code
+Author-email: meiyingm1y1 <2653708110@qq.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Encryption Algorithms Module
+
+This directory contains implementations of several classic encryption algorithms. Below is a brief description of each file:
+
+## File Descriptions
+
+### `__init__.py`
+- This file marks the current directory as a Python package.
+
+### `caesar.py`
+- Implements the Caesar Cipher encryption algorithm.
+- Caesar Cipher is a simple substitution cipher that encrypts text by shifting letters in the alphabet by a fixed number of steps.
+- Functions:
+  Caesar_encode(plaintext: str, key: int) -> str: Encrypts the given plaintext using the specified key.
+  plaintext: The input string to be encrypted.
+  key: The number of positions to shift each letter.
+- Caesar_decode(ciphertext: str) -> dict: Attempts to decrypt the ciphertext by trying all possible keys.
+   ciphertext: The encrypted string to be decrypted.
+
+### `Playfair.py`
+- Implements the Playfair Cipher encryption algorithm.
+- Playfair Cipher is an encryption method based on a letter matrix, commonly used to encrypt text.
+- Functions:
+   Playfair_encode(Keyword: str, Plaintext: str) -> str: Encrypts the plaintext using the Playfair cipher.
+   Keyword: The encryption key used to generate the matrix.
+   Plaintext: The input string to be encrypted.
+
+### `Vigenere.py`
+- Implements the Vigenère Cipher encryption algorithm.
+- Vigenère Cipher is a polyalphabetic substitution cipher that uses a key to determine the shift for each letter.
+- functions:
+   Vigenere_encode(Plaintext: str, m: int, keyword: str) -> str: Encrypts the plaintext using the Vigenère cipher.
+   Plaintext: The input string to be encrypted.
+   m: The length of the keyword.
+   keyword: The encryption key.
+## Usage
+
+1. Import the modules:
+   ```python
+   from crYpt import caesar, Playfair, Vigenere
+   ```
+
+2. Call the corresponding functions to encrypt or decrypt.
+
+## Notes
+- Ensure that the input text and key meet the requirements of each algorithm.
+- For detailed usage instructions, refer to the comments in each file.

crypt_pr-0.0.1/README.md

@@ -0,0 +1,47 @@
+# Encryption Algorithms Module
+
+This directory contains implementations of several classic encryption algorithms. Below is a brief description of each file:
+
+## File Descriptions
+
+### `__init__.py`
+- This file marks the current directory as a Python package.
+
+### `caesar.py`
+- Implements the Caesar Cipher encryption algorithm.
+- Caesar Cipher is a simple substitution cipher that encrypts text by shifting letters in the alphabet by a fixed number of steps.
+- Functions:
+  Caesar_encode(plaintext: str, key: int) -> str: Encrypts the given plaintext using the specified key.
+  plaintext: The input string to be encrypted.
+  key: The number of positions to shift each letter.
+- Caesar_decode(ciphertext: str) -> dict: Attempts to decrypt the ciphertext by trying all possible keys.
+   ciphertext: The encrypted string to be decrypted.
+
+### `Playfair.py`
+- Implements the Playfair Cipher encryption algorithm.
+- Playfair Cipher is an encryption method based on a letter matrix, commonly used to encrypt text.
+- Functions:
+   Playfair_encode(Keyword: str, Plaintext: str) -> str: Encrypts the plaintext using the Playfair cipher.
+   Keyword: The encryption key used to generate the matrix.
+   Plaintext: The input string to be encrypted.
+
+### `Vigenere.py`
+- Implements the Vigenère Cipher encryption algorithm.
+- Vigenère Cipher is a polyalphabetic substitution cipher that uses a key to determine the shift for each letter.
+- functions:
+   Vigenere_encode(Plaintext: str, m: int, keyword: str) -> str: Encrypts the plaintext using the Vigenère cipher.
+   Plaintext: The input string to be encrypted.
+   m: The length of the keyword.
+   keyword: The encryption key.
+## Usage
+
+1. Import the modules:
+   ```python
+   from crYpt import caesar, Playfair, Vigenere
+   ```
+
+2. Call the corresponding functions to encrypt or decrypt.
+
+## Notes
+- Ensure that the input text and key meet the requirements of each algorithm.
+- For detailed usage instructions, refer to the comments in each file.

crypt_pr-0.0.1/crYpt_pr/Playfair.py

@@ -0,0 +1,91 @@
+# ''.join(a)意思是以''内的元素为分割符号,把a各种元素连接起来
+def deal_with(Keyword):
+
+    if 'i' in Keyword and 'j' in Keyword:
+        Keyword = Keyword.replace('j','')
+    if 'j' in Keyword:
+        Keyword = Keyword.replace('j','i')
+    return Keyword
+
+def extract(Keyword):
+
+    List =[]
+    for i in range(len(Keyword)):
+        if Keyword[i] not in List:
+            List.append(Keyword[i])
+    return List
+
+def matrix_insert(List,matrix:list):
+
+    j=0
+    for i,j in zip(List,range(len(List))):
+        matrix[j // 5].append(i)
+    j=j+1
+    Str="abcdefghiklmnopqrstuvwxyz"
+    Str=list(Str)
+    for i in Str:
+        if i not in List:
+                matrix[j // 5].append(i)
+                j=j+1#自增不能忘
+    return matrix
+
+def transform_dict(matrix):
+
+    Dict:dict={}
+    for i in range(5):
+        for j in range(5):
+            Dict[matrix[i][j]]=(i,j)
+    return Dict
+
+def adjust(Plaintext):
+
+    i = 0
+    t = len(Plaintext)
+    if 'i' in Plaintext and 'j' in Plaintext:
+        Plaintext = Plaintext.replace('j',' ')
+    if 'j' in Plaintext:
+        Plaintext = Plaintext.replace('j','i')
+    while(i<t):
+        if(i+1<t and Plaintext[i] == Plaintext[i+1]):
+            f=''
+            List="abcdefghiklmnopqrstuvwxyz"
+            for f in List:
+                if f != Plaintext[i] and f != Plaintext[i+1]:
+                    break
+            Plaintext.insert(i+1,f)
+        i+=2
+        t=len(Plaintext)
+    return Plaintext
+
+def Playfair_encode(Keyword,Plaintext):
+
+    Keyword = deal_with(Keyword)#关键字处理
+    List = extract(Keyword)
+    matrix =[[] for i in range(5)]
+    matrix = matrix_insert(List,matrix)
+    Dict = transform_dict(matrix)#获取字符位置字典
+    Plaintext = adjust(Plaintext)#明文调整
+    Slice = [[Plaintext[i],Plaintext[i+1]] if i+1<len(Plaintext) else [Plaintext[i],'k'] \
+        for i in range(0,len(Plaintext),2)]#获取分组切片
+    for Tuple in Slice:
+        if Dict[Tuple[0]][0] != Dict[Tuple[1]][0] and Dict[Tuple[0]][1] != Dict[Tuple[1]][1] :
+            Slice[Slice.index(Tuple)] = \
+                (matrix[Dict[Tuple[0]][0]][Dict[Tuple[1]][1]],matrix[Dict[Tuple[1]][0]][Dict[Tuple[0]][1]])
+        elif Dict[Tuple[0]][1] == Dict[Tuple[1]][1]:
+            Slice[Slice.index(Tuple)] = \
+                (matrix[(Dict[Tuple[0]][0]+1)%5][Dict[Tuple[0]][1]],matrix[(Dict[Tuple[1]][0]+1)%5][Dict[Tuple[1]][1]])
+        else:
+            Slice[Slice.index(Tuple)] = \
+                (matrix[Dict[Tuple[0]][0]][(Dict[Tuple[0]][1]+1)%5],matrix[Dict[Tuple[1]][0]][(Dict[Tuple[1]][1]+1)%5])
+    ciphertext=""
+    for result in Slice:
+        ciphertext+=''.join(result)
+    return ciphertext.upper()
+
+if __name__ == "__main__" :
+    keyword = "monarchy"
+    Plaintext = "wearediscoveredsaveyourself"
+    ciphertext = Playfair_encode(keyword,Plaintext)
+    print(ciphertext)
+    
+    

crypt_pr-0.0.1/crYpt_pr/Vigenere.py

@@ -0,0 +1,27 @@
+from string import ascii_uppercase,ascii_lowercase
+
+def transmit(keyword):
+    List = list(keyword)
+    a=[]
+    for c in keyword:
+        if c in ascii_uppercase:
+            a.append((ascii_uppercase.index(c)-ascii_uppercase.index('A'))%26)
+        else:
+            a.append((ascii_lowercase.index(c)-ascii_lowercase.index('a'))%26)
+    return a  
+
+def Vigenere_encode(Plaintext,m,keyword):
+    keyword = transmit(keyword)
+    ciphertext = ""
+    for i in range(len(Plaintext)):
+        if Plaintext[i] in ascii_uppercase:
+            ciphertext += ascii_uppercase[(ascii_uppercase.index(Plaintext[i])+keyword[i%m])%26]
+        else :
+            ciphertext += ascii_lowercase[(ascii_lowercase.index(Plaintext[i])+keyword[i%m])%26]
+    return ciphertext
+
+if __name__ == "__main__":
+    keyword = "vector"
+    Plaintext = "hereishowitworks"
+    ciphertext = Vigenere_encode(Plaintext,6,keyword)
+    print(ciphertext)

crypt_pr-0.0.1/crYpt_pr/__init__.py

@@ -0,0 +1,5 @@
+from .caesar import *
+from .Playfair import *
+from .Vigenere import *
+
+

crypt_pr-0.0.1/crYpt_pr/caesar.py

@@ -0,0 +1,25 @@
+#下面实现一下凯撒密码(Caesar Crypt)的加密与唯密文解密
+
+def Caesar_encode(plaintext : str ,  key : int):
+	ciphertext=""
+	for s_chr in plaintext:
+		if (ord(s_chr)>=97 and ord(s_chr) <= 122):
+			ciphertext += chr((ord(s_chr)+key-ord('a'))%26+ord('a'))
+		elif (ord(s_chr)>=65 and ord(s_chr) <= 90):
+			ciphertext += chr((ord(s_chr)+key-ord('A'))%26+ord('A'))
+		else:
+			ciphertext += s_chr 
+	return ciphertext
+def Caesar_decode(ciphertext):
+	msg = {}
+	for key in range(1,26):
+		plaintext=""
+		for s_chr in ciphertext:
+			if (ord(s_chr) >= 97 and ord(s_chr) <=122):
+				plaintext += chr((ord(s_chr)-key-ord('a'))%26+ord('a'))
+			elif (ord(s_chr) >= 65 and ord(s_chr) <=90):
+				plaintext += chr((ord(s_chr)-key-ord('A'))%26+ord('A'))
+			else :
+				plaintext += s_chr
+		msg[key]=plaintext
+	return msg

crypt_pr-0.0.1/crYpt_pr.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: crYpt_pr
+Version: 0.0.1
+Summary: some methods about classical code
+Author-email: meiyingm1y1 <2653708110@qq.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Encryption Algorithms Module
+
+This directory contains implementations of several classic encryption algorithms. Below is a brief description of each file:
+
+## File Descriptions
+
+### `__init__.py`
+- This file marks the current directory as a Python package.
+
+### `caesar.py`
+- Implements the Caesar Cipher encryption algorithm.
+- Caesar Cipher is a simple substitution cipher that encrypts text by shifting letters in the alphabet by a fixed number of steps.
+- Functions:
+  Caesar_encode(plaintext: str, key: int) -> str: Encrypts the given plaintext using the specified key.
+  plaintext: The input string to be encrypted.
+  key: The number of positions to shift each letter.
+- Caesar_decode(ciphertext: str) -> dict: Attempts to decrypt the ciphertext by trying all possible keys.
+   ciphertext: The encrypted string to be decrypted.
+
+### `Playfair.py`
+- Implements the Playfair Cipher encryption algorithm.
+- Playfair Cipher is an encryption method based on a letter matrix, commonly used to encrypt text.
+- Functions:
+   Playfair_encode(Keyword: str, Plaintext: str) -> str: Encrypts the plaintext using the Playfair cipher.
+   Keyword: The encryption key used to generate the matrix.
+   Plaintext: The input string to be encrypted.
+
+### `Vigenere.py`
+- Implements the Vigenère Cipher encryption algorithm.
+- Vigenère Cipher is a polyalphabetic substitution cipher that uses a key to determine the shift for each letter.
+- functions:
+   Vigenere_encode(Plaintext: str, m: int, keyword: str) -> str: Encrypts the plaintext using the Vigenère cipher.
+   Plaintext: The input string to be encrypted.
+   m: The length of the keyword.
+   keyword: The encryption key.
+## Usage
+
+1. Import the modules:
+   ```python
+   from crYpt import caesar, Playfair, Vigenere
+   ```
+
+2. Call the corresponding functions to encrypt or decrypt.
+
+## Notes
+- Ensure that the input text and key meet the requirements of each algorithm.
+- For detailed usage instructions, refer to the comments in each file.

crypt_pr-0.0.1/crYpt_pr.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+crYpt_pr/Playfair.py
+crYpt_pr/Vigenere.py
+crYpt_pr/__init__.py
+crYpt_pr/caesar.py
+crYpt_pr.egg-info/PKG-INFO
+crYpt_pr.egg-info/SOURCES.txt
+crYpt_pr.egg-info/dependency_links.txt
+crYpt_pr.egg-info/top_level.txt

crypt_pr-0.0.1/crYpt_pr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

crypt_pr-0.0.1/crYpt_pr.egg-info/top_level.txt

@@ -0,0 +1 @@
+crYpt_pr

crypt_pr-0.0.1/pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "crYpt_pr"
+version = "0.0.1"
+authors = [
+  { name="meiyingm1y1", email="2653708110@qq.com" },
+]
+description = "some methods about classical code"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+

crypt_pr-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+