[text] sys

Viewer

*** This page was generated with the meta tag "noindex, nofollow". This happened because you selected this option before saving or the system detected it as spam. This means that this page will never get into the search engines and the search bot will not crawl it. There is nothing to worry about, you can still share it with anyone.

copy download embed printName: sys

1.CEASER:
#include <iostream>
#include <string>
using namespace std;
bool isAlpha(char ch){
return isalpha(ch);
}
char encryptChar(char c, int shift){
if(isupper(c)){
c = (((c-'A')+shift)%26)+'A';
}
else if(islower(c)){
c = (((c-'a')+shift)%26)+'a';
}
else{
return c;
}
return c;
}
string encryptCaesar(string c, int shift){
string encryptedtext;
for(char ch:c){
encryptedtext+=encryptChar(ch, shift);
}
return encryptedtext;
}
int main()
{
string text;
int n;
cout<<"Enter text to be encrypted: ";
getline(cin,text);
cout<<"Enter key value: ";
cin>>n;
cout<<encryptCaesar(text, n);
return 0;
}
2. HILL:
Hill Cipher
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
const int MOD = 26; // modulo for encryption
// Function to convert character to integer (A -> 0, B -> 1, ..., Z -> 25)
int charToInt(char ch) {
return ch - 'A';
}
// Function to convert integer to character (0 -> A, 1 -> B, ..., 25 -> Z)
char intToChar(int n) {
return 'A' + n;
}
// Function to compute the modular inverse of a number a mod m
int modInverse(int a, int m) {
a = a % m;
for (int x = 1; x < m; x++) {
if ((a * x) % m == 1) {
return x;
}
}
return -1; // modular inverse doesn't exist
}
// Function to encrypt a plaintext using the Hill cipher
string hillEncrypt(const string& plaintext, const vector<vector<int>>& key) {
int n = key.size();
string ciphertext = "";
// Padding the plaintext if necessary
string paddedPlaintext = plaintext;
int padding = n - (plaintext.length() % n);
if (padding != n) {
paddedPlaintext += string(padding, 'X');
}
// Encryption
for (int i = 0; i < paddedPlaintext.length(); i += n) {
vector<int> block(n);
for (int j = 0; j < n; j++) {
block[j] = charToInt(paddedPlaintext[i + j]);
}
for (int j = 0; j < n; j++) {
int sum = 0;
for (int k = 0; k < n; k++) {
sum += key[j][k] * block[k];
}
ciphertext += intToChar(sum % MOD);
}
}
return ciphertext;
}
int main() {
// Example key matrix
vector<vector<int>> key = {{6, 24, 1},
{13, 16, 10},
{20, 17, 15}};
// Example plaintext
string plaintext = "HELLO";
// Encrypt the plaintext
string ciphertext = hillEncrypt(plaintext, key);
cout << "Plaintext: " << plaintext << endl;
cout << "Ciphertext: " << ciphertext << endl;
return 0;
}
3. Playfair/wheatstone cipher:
#include <iostream>
#include <string>
#include <cctype>
#include <vector>
using namespace std;
// Function to get the position of a character in the key table
void getPos(char ch, int& row, int& col, const char table[][5]) {
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (table[i][j] == toupper(ch)) {
row = i;
col = j;
return;
}
}
}
}
// Function to check if a character is unique in the key
bool isUniqueInKey(char ch, const string& key) {
for (char keyChar : key) {
if (toupper(ch) == toupper(keyChar)) {
return false;
}
}
return true;
}
// Function to create the Playfair key table
void createTable(const string& key, char table[][5]) {
// Fill the table with characters from the key (uppercase, no duplicates)
int index = 0;
for (char ch : key) {
ch = toupper(ch);
if (isalpha(ch) && ch != 'J') {
table[index / 5][index % 5] = ch;
index++;
}
}
// Fill the remaining table with the rest of the alphabets (excluding J)
for (char ch = 'A'; ch <= 'Z'; ch++) {
if (ch != 'J' && isUniqueInKey(ch, key)) {
table[index / 5][index % 5] = ch;
index++;
}
}
}
// Function to encrypt a pair of characters using Playfair cipher
string encryptPair(char ch1, char ch2, const char table[][5]) {
int row1, col1, row2, col2;
// Get positions of characters in the table
getPos(ch1, row1, col1, table);
getPos(ch2, row2, col2, table);
// Handle different cases based on positions
string encryptedPair;
if (row1 == row2) {
// Same row, shift columns (cyclic)
encryptedPair += table[row1][(col1 + 1) % 5];
encryptedPair += table[row2][(col2 + 1) % 5];
} else if (col1 == col2) {
// Same column, shift rows (cyclic)
encryptedPair += table[(row1 + 1) % 5][col1];
encryptedPair += table[(row2 + 1) % 5][col2];
} else {
// Different row and column, swap positions within the rectangle
encryptedPair += table[row1][col2];
encryptedPair += table[row2][col1];
}
return encryptedPair;
}
string encryptPlayfair(const string& text, const string& key) {
string encryptedText;
char table[5][5];
// Create the Playfair key table
createTable(key, table);
// Handle even number of characters (add 'X')
string formattedText = text;
if (text.length() % 2 != 0) {
formattedText += 'X';
}
// Process each pair of characters
for (int i = 0; i < formattedText.length(); i += 2) {
encryptedText += encryptPair(formattedText[i], formattedText[i + 1], table);
}
return encryptedText;
}
int main() {
string text, key;
cout << "Enter the text to be encrypted: ";
getline(cin, text);
cout << "Enter the key: ";
getline(cin, key);
string encryptedText = encryptPlayfair(text, key);
cout << "The encrypted text is: " << encryptedText << endl;
return 0;
}
5. Vernam Cipher –
def vernam_cipher(text, key):
# Ensure the length of the key matches the length of the text
if len(text) != len(key):
raise ValueError("Key length must be equal to the length of the text")
result = ""
for i in range(len(text)):
# XOR each character of the text with the corresponding character of the key
# Convert characters to ASCII values for bitwise operations
encrypted_char = chr(ord(text[i]) ^ ord(key[i]))
result += encrypted_char
return result
# Example usage
text = "Hello"
key = "Secret"
encrypted_text = vernam_cipher(text, key)
print("Encrypted:", encrypted_text)
decrypted_text = vernam_cipher(encrypted_text, key)
print("Decrypted:", decrypted_text)
RAIL FENCE –
def rail_fence_encrypt(text, rails):
# Create an empty list to store the rails
fence = [[] for _ in range(rails)]
# Initialize variables for tracking the current rail and direction
rail = 0
direction = 1
# Place each character of the text on the appropriate rail
for char in text:
fence[rail].append(char)
rail += direction
# Reverse direction when reaching the top or bottom rail
if rail == 0 or rail == rails - 1:
direction *= -1
# Concatenate the characters from each rail to form the encrypted text
encrypted_text = ''.join(''.join(rail) for rail in fence)
return encrypted_text
def rail_fence_decrypt(text, rails):
# Create an empty list to store the rails
fence = [[] for _ in range(rails)]
# Initialize variables for tracking the current rail and direction
rail = 0
direction = 1
# Calculate the length of each rail based on the pattern
cycle = 2 * (rails - 1)
full_cycles = len(text) // cycle
remainder = len(text) % cycle
# Place markers on the appropriate rails to indicate the zigzag pattern
markers = [rail] * (full_cycles * 2) + [0] * (remainder if remainder <= rails else rails - 1 - remainder + rails) + [rail] * (full_cycles * 2)
# Place each character of the text on the appropriate rail
for i, char in enumerate(text):
fence[markers[i]].append(char)
# Concatenate the characters from each rail to form the decrypted text
decrypted_text = ''.join(''.join(rail) for rail in fence)
return decrypted_text
# Example usage
text = "HELLO"
rails = 3
encrypted_text = rail_fence_encrypt(text, rails)
print("Encrypted:", encrypted_text)
decrypted_text = rail_fence_decrypt(encrypted_text, rails)
print("Decrypted:", decrypted_text)
6. ROW COLUMN –
def encrypt(text, key):
# Calculate the number of columns based on the key length
num_columns = len(key)
# Calculate the number of rows needed to accommodate the text
num_rows = (len(text) + num_columns - 1) // num_columns
# Pad the text if necessary
padded_text = text.ljust(num_rows * num_columns)
# Construct the grid based on the number of rows and columns
grid = [list(padded_text[i:i+num_columns]) for i in range(0, len(padded_text), num_columns)]
# Create a list to store the encrypted columns based on the key order
encrypted_columns = [grid[j] for j in key]
# Construct the encrypted text by reading off the columns
encrypted_text = ''.join(''.join(column) for column in encrypted_columns)
return encrypted_text
def decrypt(text, key):
# Calculate the number of columns based on the key length
num_columns = len(key)
# Calculate the number of rows needed to accommodate the text
num_rows = (len(text) + num_columns - 1) // num_columns
# Construct the grid based on the number of rows and columns
grid = [list(text[i:i+num_rows]) for i in range(0, len(text), num_rows)]
# Create a list to store the decrypted columns based on the key order
decrypted_columns = [grid[j] for j in sorted(key)]
# Construct the decrypted text by reading off the columns
decrypted_text = ''.join(''.join(column) for column in zip(*decrypted_columns))
return decrypted_text
# Example usage
text = "HELLO"
key = [2, 1, 3] # Example key
encrypted_text = encrypt(text, key)
print("Encrypted:", encrypted_text)
decrypted_text = decrypt(encrypted_text, key)
print("Decrypted:", decrypted_text)
----------------------------------------------------------------------
SSL:
SERVER:
import socket
import ssl
import tempfile
import os
HOST = '127.0.0.1'
PORT = 12345
def generate_self_signed_cert():
certfile = tempfile.NamedTemporaryFile(delete=False)
keyfile = tempfile.NamedTemporaryFile(delete=False)
# Generate a self-signed certificate
os.system(f'openssl req -new -newkey rsa:2048 -days 365 -nodes -x509 -keyout {keyfile.name} -out {certfile.name} -subj "/CN=localhost"')
return certfile.name, keyfile.name
def main():
try:
# Generate self-signed certificate and key
certfile, keyfile = generate_self_signed_cert()
# Create a TCP/IP socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Bind the socket to the port
server_socket.bind((HOST, PORT))
# Listen for incoming connections
server_socket.listen(1)
print(f"Server listening on {HOST}:{PORT}...")
while True:
# Accept incoming connections
connection, client_address = server_socket.accept()
print(f"Connection from {client_address}")
# Wrap the connection with SSL
ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_context.load_cert_chain(certfile=certfile, keyfile=keyfile)
ssl_connection = ssl_context.wrap_socket(connection, server_side=True)
try:
while True:
# Receive data from the client
data = ssl_connection.recv(1024)
if data:
print(f"Received: {data.decode()}")
else:
break
finally:
# Close the connection
ssl_connection.close()
except Exception as e:
print(f"An error occurred: {e}")
if __name__ == "__main__":
main()
CLIENT:
import socket
import ssl
HOST = '127.0.0.1'
PORT = 12345
def main():
try:
# Create a TCP/IP socket
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Wrap the socket with SSL, ignoring certificate verification errors
ssl_context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE
ssl_socket = ssl_context.wrap_socket(client_socket, server_hostname=HOST)
try:
# Connect to the server
ssl_socket.connect((HOST, PORT))
# Send data to the server
message = "21BCE1370 Vrinda"
print(f"Sending: {message}")
ssl_socket.sendall(message.encode())
# Receive data from the server
data = ssl_socket.recv(1024)
print(f"Received: {data.decode()}")
except ConnectionRefusedError:
print("Connection refused. Make sure the server is running.")
finally:
# Close the connection
ssl_socket.close()
except Exception as e:
print(f"An error occurred: {e}")
if __name__ == "__main__":
main()
1. AES
REC
import socket
INV_S_BOX_STRING = '52 09 6a d5 30 36 a5 38 bf 40 a3 9e 81 f3 d7 fb' \
'7c e3 39 82 9b 2f ff 87 34 8e 43 44 c4 de e9 cb' \
'54 7b 94 32 a6 c2 23 3d ee 4c 95 0b 42 fa c3 4e' \
'08 2e a1 66 28 d9 24 b2 76 5b a2 49 6d 8b d1 25' \
'72 f8 f6 64 86 68 98 16 d4 a4 5c cc 5d 65 b6 92' \
'6c 70 48 50 fd ed b9 da 5e 15 46 57 a7 8d 9d 84' \
'90 d8 ab 00 8c bc d3 0a f7 e4 58 05 b8 b3 45 06' \
'd0 2c 1e 8f ca 3f 0f 02 c1 af bd 03 01 13 8a 6b' \
'3a 91 11 41 4f 67 dc ea 97 f2 cf ce f0 b4 e6 73' \
'96 ac 74 22 e7 ad 35 85 e2 f9 37 e8 1c 75 df 6e' \
'47 f1 1a 71 1d 29 c5 89 6f b7 62 0e aa 18 be 1b' \
'fc 56 3e 4b c6 d2 79 20 9a db c0 fe 78 cd 5a f4' \
'1f dd a8 33 88 07 c7 31 b1 12 10 59 27 80 ec 5f' \
'60 51 7f a9 19 b5 4a 0d 2d e5 7a 9f 93 c9 9c ef' \
'a0 e0 3b 4d ae 2a f5 b0 c8 eb bb 3c 83 53 99 61' \
'17 2b 04 7e ba 77 d6 26 e1 69 14 63 55 21 0c 7d'.replace(" ", "")
S_BOX_STRING = '63 7c 77 7b f2 6b 6f c5 30 01 67 2b fe d7 ab 76' \
'ca 82 c9 7d fa 59 47 f0 ad d4 a2 af 9c a4 72 c0' \
'b7 fd 93 26 36 3f f7 cc 34 a5 e5 f1 71 d8 31 15' \
'09 83 2c 1a 1b 6e 5a a0 52 3b d6 b3 29 e3 2f 84' \
'53 d1 00 ed 20 fc b1 5b 6a cb be 39 4a 4c 58 cf' \
'd0 ef aa fb 43 4d 33 85 45 f9 02 7f 50 3c 9f a8' \
'51 a3 40 8f 92 9d 38 f5 bc b6 da 21 10 ff f3 d2' \
'cd 0c 13 ec 5f 97 44 17 c4 a7 7e 3d 64 5d 19 73' \
'60 81 4f dc 22 2a 90 88 46 ee b8 14 de 5e 0b db' \
'e0 32 3a 0a 49 06 24 5c c2 d3 ac 62 91 95 e4 79' \
'e7 c8 37 6d 8d d5 4e a9 6c 56 f4 ea 65 7a ae 08' \
'ba 78 25 2e 1c a6 b4 c6 e8 dd 74 1f 4b bd 8b 8a' \
'70 3e b5 66 48 03 f6 0e 61 35 57 b9 86 c1 1d 9e' \
'e1 f8 98 11 69 d9 8e 94 9b 1e 87 e9 ce 55 28 df' \
'8c a1 89 0d bf e6 42 68 41 99 2d 0f b0 54 bb 16'.replace(" ", "")
S_BOX = bytearray.fromhex(S_BOX_STRING)
INV_S_BOX = bytearray.fromhex(INV_S_BOX_STRING)
def inv_shift_rows(state: [[int]]) -> [[int]]:
state[1][1], state[2][1], state[3][1], state[0][1] = state[0][1], state[1][1], state[2][1], state[3][1]
state[2][2], state[3][2], state[0][2], state[1][2] = state[0][2], state[1][2], state[2][2], state[3][2]
state[3][3], state[0][3], state[1][3], state[2][3] = state[0][3], state[1][3], state[2][3], state[3][3]
return
def inv_sub_bytes(state: [[int]]) -> [[int]]:
for r in range(len(state)):
state[r] = [INV_S_BOX[state[r][c]] for c in range(len(state[0]))]
def xtime(a: int) -> int:
if a & 0x80:
return ((a << 1) ^ 0x1b) & 0xff
return a << 1
def xtimes_0e(b):
# 0x0e = 14 = b1110 = ((x * 2 + x) * 2 + x) * 2
return xtime(xtime(xtime(b) ^ b) ^ b)
def xtimes_0b(b):
# 0x0b = 11 = b1011 = ((x*2)*2+x)*2+x
return xtime(xtime(xtime(b)) ^ b) ^ b
def xtimes_0d(b):
# 0x0d = 13 = b1101 = ((x*2+x)*2)*2+x
return xtime(xtime(xtime(b) ^ b)) ^ b
def xtimes_09(b):
# 0x09 = 9 = b1001 = ((x*2)*2)*2+x
return xtime(xtime(xtime(b))) ^ b
def mix_column(col: [int]):
c_0 = col[0]
all_xor = col[0] ^ col[1] ^ col[2] ^ col[3]
col[0] ^= all_xor ^ xtime(col[0] ^ col[1])
col[1] ^= all_xor ^ xtime(col[1] ^ col[2])
col[2] ^= all_xor ^ xtime(col[2] ^ col[3])
col[3] ^= all_xor ^ xtime(c_0 ^ col[3])
def mix_columns(state: [[int]]):
for r in state:
mix_column(r)
def state_from_bytes(data: bytes) -> [[int]]:
state = [data[i*4:(i+1)*4] for i in range(len(data) // 4)]
return state
def bytes_from_state(state: [[int]]) -> bytes:
return bytes(state[0] + state[1] + state[2] + state[3])
def add_round_key(state: [[int]], key_schedule: [[[int]]], round: int):
round_key = key_schedule[round]
for r in range(len(state)):
state[r] = [state[r][c] ^ round_key[r][c] for c in range(len(state[0]))]
def inv_mix_column(col: [int]):
c_0, c_1, c_2, c_3 = col[0], col[1], col[2], col[3]
col[0] = xtimes_0e(c_0) ^ xtimes_0b(c_1) ^ xtimes_0d(c_2) ^ xtimes_09(c_3)
col[1] = xtimes_09(c_0) ^ xtimes_0e(c_1) ^ xtimes_0b(c_2) ^ xtimes_0d(c_3)
col[2] = xtimes_0d(c_0) ^ xtimes_09(c_1) ^ xtimes_0e(c_2) ^ xtimes_0b(c_3)
col[3] = xtimes_0b(c_0) ^ xtimes_0d(c_1) ^ xtimes_09(c_2) ^ xtimes_0e(c_3)
def inv_mix_columns(state: [[int]]) -> [[int]]:
for g in state:
inv_mix_column(r)
def inv_mix_column_optimized(col: [int]):
u = xtime(xtime(col[0] ^ col[2]))
v = xtime(xtime(col[1] ^ col[3]))
col[0] ^= u
col[1] ^= v
col[2] ^= u
col[3] ^= v
def inv_mix_columns_optimized(state: [[int]]) -> [[int]]:
for r in state:
inv_mix_column_optimized(r)
mix_columns(state)
def xor_bytes(a: bytes, b: bytes) -> bytes:
return bytes([x ^ y for (x, y) in zip(a, b)])
def rot_word(word: [int]) -> [int]:
return word[1:] + word[:1]
def sub_word(word: [int]) -> bytes:
substituted_word = bytes(S_BOX[i] for i in word)
return substituted_word
def rcon(i: int) -> bytes:
rcon_lookup = bytearray.fromhex('0102040810204081b36')
rcon_value = bytes([rcon_lookup[i-1], 0, 0, 0])
return rcon_value
def key_expansion(key: bytes, nb: int = 4) -> [[[int]]]:
nk = len(key) // 4
key_bit_length = len(key) * 8
if key_bit_length == 128:
nr = 10
elif key_bit_length == 192:
nr = 12
else: # 256-bit keys
nr = 14
w = state_from_bytes(key)
for i in range(nk, nb * (nr + 1)):
temp = w[i-1]
if i % nk == 0:
temp = xor_bytes(sub_word(rot_word(temp)), rcon(i // nk))
elif nk > 6 and i % nk == 4:
temp = sub_word(temp)
w.append(xor_bytes(w[i - nk], temp))
return [w[i*4:(i+1)*4] for i in range(len(w) // 4)]
def aes_decryption(cipher: bytes, key: bytes) -> bytes:
key_byte_length = len(key)
key_bit_length = key_byte_length * 8
nk = key_byte_length // 4
if key_bit_length == 128:
nr = 10
elif key_bit_length == 192:
nr = 12
else: # 256-bit keys
nr = 14
state = state_from_bytes(cipher)
key_schedule = key_expansion(key)
add_round_key(state, key_schedule, round=nr)
for round in range(nr, 0, -1):
inv_shift_rows(state)
inv_sub_bytes(state)
add_round_key(state, key_schedule, round)
inv_mix_columns(state)
print("Round ", round, " : ", state)
inv_shift_rows(state)
inv_sub_bytes(state)
add_round_key(state, key_schedule, round=0)
plain = bytes_from_state(state)
return plain
key = bytearray.fromhex('00010203040060708090a0b0c0d0e0f')
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('127.0.0.1', 1111))
s.listen(1)
conn, addr = s.accept()
data = conn.recv(1024)
print("Received Encrypted Data: ", data)
print("Decrypted Data: ", aes_decryption(data, key).decode('utf-8'))
conn.close()
#1st run receiver.py tehn run sender.py then put in the value in the sender.py and see the output in the receiver.py
SEN
import socket
# CONSTANTS
S_BOX_STRING = '63 7c 77 7b f2 6b 6f c5 30 01 67 2b fe d7 ab 76' \
'ca 82 c9 7d fa 59 47 f0 ad d4 a2 af 9c a4 72 c0' \
'b7 fd 93 26 36 3f f7 cc 34 a5 e5 f1 71 d8 31 15' \
'04 c7 23 c3 18 96 05 9a 07 12 80 e2 eb 27 b2 75' \
'09 83 2c 1a 1b 6e 5a a0 52 3b d6 b3 29 e3 2f 84' \
'53 d1 00 ed 20 fc b1 5b 6a cb be 39 4a 4c 58 cf' \
'd0 ef aa fb 43 4d 33 85 45 f9 02 7f 50 3c 9f a8' \
'51 a3 40 8f 92 9d 38 f5 bc b6 da 21 10 ff f3 d2' \
'cd 0c 13 ec 5f 97 44 17 c4 a7 7e 3d 64 5d 19 73' \
'60 81 4f dc 22 2a 90 88 46 ee b8 14 de 5e 0b db' \
'e0 32 3a 0a 49 06 24 5c c2 d3 ac 62 91 95 e4 79' \
'e7 c8 37 6d 8d d5 4e a9 6c 56 f4 ea 65 7a ae 08' \
'ba 78 25 2e 1c a6 b4 c6 e8 dd 74 1f 4b bd 8b 8a' \
'70 3e b5 66 48 03 f6 0e 61 35 57 b9 86 c1 1d 9e' \
'8c a1 89 0d bf e6 42 68 41 99 2d 0f b0 54 bb 16'.replace(" ", "")
S_BOX = bytearray.fromhex(S_BOX_STRING)
def sub_word(word: [int]) -> bytes:
substituted_word = bytes(S_BOX[i] for i in word)
return substituted_word
def rcon(i: int) -> bytes:
rcon_lookup = bytearray.fromhex('0100408102040801b36')
rcon_value = bytes([rcon_lookup[i-1], 0, 0, 0])
return rcon_value
def xor_bytes(a: bytes, b: bytes) -> bytes:
return bytes([x ^ y for (x, y) in zip(a, b)])
def rot_word(word: [int]) -> [int]:
return word[1:] + word[:1]
def key_expansion(key: bytes, nb: int = 4) -> [[[int]]]:
nk = len(key) // 4
key_bit_length = len(key) * 8
if key_bit_length == 128:
nr = 10
elif key_bit_length == 192:
nr = 12
else: # 256-bit keys
nr = 14
w = state_from_bytes(key)
for i in range(nk, nb * (nr + 1)):
temp = w[i-1]
if i % nk == 0:
temp = xor_bytes(sub_word(rot_word(temp)), rcon(i // nk))
elif nk > 6 and i % nk == 4:
temp = sub_word(temp)
w.append(xor_bytes(w[i - nk], temp))
return [w[i*4:(i+1)*4] for i in range(len(w) // 4)]
def add_round_key(state: [[int]], key_schedule: [[[int]]], round: int):
round_key = key_schedule[round]
for r in range(len(state)):
state[r] = [state[r][c] ^ round_key[r][c] for c in range(len(state[0]))]
def sub_bytes(state: [[int]]):
for r in range(len(state)):
state[r] = [S_BOX[state[r][c]] for c in range(len(state[0]))]
def shift_rows(state: [[int]]):
state[0][1], state[1][1], state[2][1], state[3][1] = state[1][1], state[2][1], state[3][1], state[0][1]
state[0][2], state[1][2], state[2][2], state[3][2] = state[2][2], state[3][2], state[0][2], state[1][2]
state[0][3], state[1][3], state[2][3], state[3][3] = state[3][3], state[0][3], state[1][3], state[2][3]
def xtime(a: int) -> int:
if a & 0x80:
return ((a << 1) ^ 0x1b) & 0xff
return a << 1
def mix_column(col: [int]):
c_0 = col[0]
all_xor = col[0] ^ col[1] ^ col[2] ^ col[3]
col[0] ^= all_xor ^ xtime(col[0] ^ col[1])
col[1] ^= all_xor ^ xtime(col[1] ^ col[2])
col[2] ^= all_xor ^ xtime(col[2] ^ col[3])
col[3] ^= all_xor ^ xtime(c_0 ^ col[3])
def mix_columns(state: [[int]]):
for r in state:
mix_column(r)
def state_from_bytes(data: bytes) -> [[int]]:
state = [data[i*4:(i+1)*4] for i in range(len(data) // 4)]
return state
def bytes_from_state(state: [[int]]) -> bytes:
return bytes(state[0] + state[1] + state[2] + state[3])
def aes_encryption(data: bytes, key: bytes) -> bytes:
state = state_from_bytes(data)
key_schedule = key_expansion(key)
add_round_key(state, key_schedule, round=0)
for round in range(1, 11):
sub_bytes(state)
shift_rows(state)
mix_columns(state)
add_round_key(state, key_schedule, round)
print("Round ", round, " : ", state)
sub_bytes(state)
shift_rows(state)
add_round_key(state, key_schedule, round=10)
cipher = bytes_from_state(state)
return cipher
if name == "main":
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = ('127.0.0.1', 1111)
s.connect(server_address)
plaintext = input("Enter the plaintext: ")
block_size = 16
padding_length = block_size - (len(plaintext) % block_size)
plaintext += chr(padding_length) * padding_length
plaintext_bytes = plaintext.encode()
key = bytearray.fromhex('00010203040060708090a0b0c0d0e0f')
ciphertext = aes_encryption(plaintext_bytes, key)
print("Ciphertext (hex): ", ciphertext.hex())
s.sendall(ciphertext)
2. DES
CLIENT
import socket
INITIAL_PERM = [58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7]
D = [32, 1, 2, 3, 4, 5, 4, 5,
6, 7, 8, 9, 8, 9, 10, 11,
12, 13, 12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21, 20, 21,
22, 23, 24, 25, 24, 25, 26, 27,
28, 29, 28, 29, 30, 31, 32, 1]
PERM = [16, 7, 20, 21,
29, 12, 28, 17,
1, 15, 23, 26,
5, 18, 31, 10,
2, 8, 24, 14,
32, 27, 3, 9,
19, 13, 30, 6,
22, 11, 4, 25]
SBOX = [[[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],
[0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],
[4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],
[15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]],
[[15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],
[3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],
[0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],
[13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]],
[[10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],
[13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],
[13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],
[1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]],
[[7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],
[13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9],
[10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],
[3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]],
[[2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],
[14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],
[4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],
[11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]],
[[12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],
[10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],
[9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],
[4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]],
[[4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],
[13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],
[1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],
[6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]],
[[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],
[1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],
[7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],
[2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]]]
FPERM = [40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
33, 1, 41, 9, 49, 17, 57, 25]
# --parity bit drop table
KEYP = [57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15,
7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4]
# Number of bit shifts
SHIFT_TABLE = [1, 1, 2, 2,
2, 2, 2, 2,
1, 2, 2, 2,
2, 2, 2, 1]
# Key- Compression Table : Compression of key from 56 bits to 48 bits
KEY_COMP = [14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32]
def hex2bin(s):
mp = {'0': "0000",
'1': "0001",
'2': "0010",
'3': "0011",
'4': "0100",
'5': "0101",
'6': "0110",
'7': "0111",
'8': "1000",
'9': "1001",
'A': "1010",
'B': "1011",
'C': "1100",
'D': "1101",
'E': "1110",
'F': "1111"}
bin = ""
for i in range(len(s)):
bin = bin + mp[s[i]]
return bin
def bin2hex(s):
mp = {"0000": '0',
"0001": '1',
"0010": '2',
"0011": '3',
"0100": '4',
"0101": '5',
"0110": '6',
"0111": '7',
"1000": '8',
"1001": '9',
"1010": 'A',
"1011": 'B',
"1100": 'C',
"1101": 'D',
"1110": 'E',
"1111": 'F'}
hex = ""
for i in range(0, len(s), 4):
ch = ""
ch = ch + s[i]
ch = ch + s[i + 1]
ch = ch + s[i + 2]
ch = ch + s[i + 3]
hex = hex + mp[ch]
return hex
def bin2dec(binary):
binary1 = binary
decimal, i, n = 0, 0, 0
while(binary != 0):
dec = binary % 10
decimal = decimal + dec * pow(2, i)
binary = binary//10
i += 1
return decimal
def dec2bin(num):
res = bin(num).replace("0b", "")
if(len(res) % 4 != 0):
div = len(res) / 4
div = int(div)
counter = (4 * (div + 1)) - len(res)
for i in range(0, counter):
res = '0' + res
return res
def permute(k, arr, n):
permutation = ""
for i in range(0, n):
permutation = permutation + k[arr[i] - 1]
return permutation
def shift_left(k, nth_shifts):
s = ""
for i in range(nth_shifts):
for j in range(1, len(k)):
s = s + k[j]
s = s + k[0]
k = s
s = ""
return k
def xor(a, b):
ans = ""
for i in range(len(a)):
if a[i] == b[i]:
ans = ans + "0"
else:
ans = ans + "1"
return ans
def encrypt(pt, rkb, rk):
pt = hex2bin(pt)
pt = permute(pt, INITIAL_PERM, 64)
print("After initial permutation", bin2hex(pt))
left = pt[0:32]
right = pt[32:64]
for i in range(0, 16):
right_expanded = permute(right, D, 48)
xor_x = xor(right_expanded, rkb[i])
sbox_str = ""
for j in range(0, 8):
row = bin2dec(int(xor_x[j * 6] + xor_x[j * 6 + 5]))
col = bin2dec(
int(xor_x[j * 6 + 1] + xor_x[j * 6 + 2] + xor_x[j * 6 + 3] + xor_x[j * 6 + 4]))
val = SBOX[j][row][col]
sbox_str = sbox_str + dec2bin(val)
sbox_str = permute(sbox_str, PERM, 32)
result = xor(left, sbox_str)
left = result
if(i != 15):
left, right = right, left
print("Round ", i + 1, " ", bin2hex(left),
" ", bin2hex(right), " ", rk[i])
combine = left + right
cipher_text = permute(combine, FPERM, 64)
return cipher_text
def keygen(key):
key = hex2bin(key)
key = permute(key, KEYP, 56)
left = key[0:28]
right = key[28:56]
rkb = []
rk = []
for i in range(0, 16):
left = shift_left(left, SHIFT_TABLE[i])
right = shift_left(right, SHIFT_TABLE[i])
combine_str = left + right
round_key = permute(combine_str, KEY_COMP, 48)
rkb.append(round_key)
rk.append(bin2hex(round_key))
return rkb, rk
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
port = 1234
ip = '127.0.0.1'
s.connect((ip, port))
data = input("Enter Hexadecimal data to send: ")
key ="AABB09182736CCDD"
rkb, rk = keygen(key)
cipher_text = bin2hex(encrypt(data, rkb, rk))
print("Cipher Text : ", cipher_text)
s.send(cipher_text.encode())
s.close()
SENDER
import socket
INITIAL_PERM = [58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7]
D = [32, 1, 2, 3, 4, 5, 4, 5,
6, 7, 8, 9, 8, 9, 10, 11,
12, 13, 12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21, 20, 21,
22, 23, 24, 25, 24, 25, 26, 27,
28, 29, 28, 29, 30, 31, 32, 1]
PERM = [16, 7, 20, 21,
29, 12, 28, 17,
1, 15, 23, 26,
5, 18, 31, 10,
2, 8, 24, 14,
32, 27, 3, 9,
19, 13, 30, 6,
22, 11, 4, 25]
SBOX = [[[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],
[0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],
[4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],
[15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]],
[[15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],
[3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],
[0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],
[13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]],
[[10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],
[13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],
[13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],
[1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]],
[[7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],
[13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9],
[10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],
[3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]],
[[2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],
[14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],
[4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],
[11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]],
[[12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],
[10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],
[9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],
[4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]],
[[4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],
[13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],
[1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],
[6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]],
[[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],
[1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],
[7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],
[2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]]]
FPERM = [40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25]
# --parity bit drop table
KEYP = [57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15,
7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4]
# Number of bit shifts
SHIFT_TABLE = [1, 1, 2, 2,
2, 2, 2, 2,
1, 2, 2, 2,
2, 2, 2, 1]
# Key- Compression Table : Compression of key from 56 bits to 48 bits
KEY_COMP = [14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32]
def hex2bin(s):
mp = {'0': "0000",
'1': "0001",
'2': "0010",
'3': "0011",
'4': "0100",
'5': "0101",
'6': "0110",
'7': "0111",
'8': "1000",
'9': "1001",
'A': "1010",
'B': "1011",
'C': "1100",
'D': "1101",
'E': "1110",
'F': "1111"}
bin = ""
for i in range(len(s)):
bin = bin + mp[s[i]]
return bin
def bin2hex(s):
mp = {"0000": '0',
"0001": '1',
"0010": '2',
"0011": '3',
"0100": '4',
"0101": '5',
"0110": '6',
"0111": '7',
"1000": '8',
"1001": '9',
"1010": 'A',
"1011": 'B',
"1100": 'C',
"1101": 'D',
"1110": 'E',
"1111": 'F'}
hex = ""
for i in range(0, len(s), 4):
ch = ""
ch = ch + s[i]
ch = ch + s[i + 1]
ch = ch + s[i + 2]
ch = ch + s[i + 3]
hex = hex + mp[ch]
return hex
def bin2dec(binary):
binary1 = binary
decimal, i, n = 0, 0, 0
while(binary != 0):
dec = binary % 10
decimal = decimal + dec * pow(2, i)
binary = binary//10
i += 1
return decimal
def dec2bin(num):
res = bin(num).replace("0b", "")
if(len(res) % 4 != 0):
div = len(res) / 4
div = int(div)
counter = (4 * (div + 1)) - len(res)
for i in range(0, counter):
res = '0' + res
return res
def permute(k, arr, n):
permutation = ""
for i in range(0, n):
permutation = permutation + k[arr[i] - 1]
return permutation
def shift_left(k, nth_shifts):
s = ""
for i in range(nth_shifts):
for j in range(1, len(k)):
s = s + k[j]
s = s + k[0]
k = s
s = ""
return k
def xor(a, b):
ans = ""
for i in range(len(a)):
if a[i] == b[i]:
ans = ans + "1"
else:
ans = ans + "0"
return ans
def encrypt(pt, rkb, rk):
pt = hex2bin(pt)
# Initial Permutation
pt = permute(pt, INITIAL_PERM, 64)
print("After initial permutation", bin2hex(pt))
# Splitting
left = pt[0:32]
right = pt[32:64]
for i in range(0, 16):
# Expansion D-box: Expanding the 32 bits data into 48 bits
right_expanded = permute(right, D, 48)
xor_x = xor(right_expanded, rkb[i])
sbox_str = ""
for j in range(0, 8):
row = bin2dec(int(xor_x[j * 6] + xor_x[j * 6 + 5]))
col = bin2dec(
int(xor_x[j * 6 + 1] + xor_x[j * 6 + 2] + xor_x[j * 6 + 3] + xor_x[j * 6 + 4]))
val = SBOX[j][row][col]
sbox_str = sbox_str + dec2bin(val)
sbox_str = permute(sbox_str, PERM, 32)
result = xor(left, sbox_str)
left = result
if(i != 15):
left, right = right, left
print("Round ", i + 1, " ", bin2hex(left),
" ", bin2hex(right), " ", rk[i])
combine = left + right
cipher_text = permute(combine, FPERM, 64)
return cipher_text
def keygen(key):
key = hex2bin(key)
key = permute(key, KEYP, 56)
left = key[0:28]
right = key[28:56]
rkb = []
rk = []
for i in range(0, 16):
left = shift_left(left, SHIFT_TABLE[i])
right = shift_left(right, SHIFT_TABLE[i])
combine_str = left + right
round_key = permute(combine_str, KEY_COMP, 48)
rkb.append(round_key)
rk.append(bin2hex(round_key))
return rkb, rk
key = input("Enter the hex key: ")
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
port = 1234
ip = '127.0.0.1'
s.bind((ip, port))
s.listen(5)
c, addr = s.accept()
data = c.recv(1024).decode()
rkb, rk = keygen(key)
print("Decryption")
rkb_rev = rkb[::-1]
rk_rev = rk[::-1]
text = bin2hex(encrypt(data, rkb_rev, rk_rev))
print("Plain Text : ", text)
3. DIFFY
ALICE
import socket
import math
def mod_exp(base, exponent, modulus):
return pow(base, exponent, modulus)
def compute_Y(alpha, X, q):
return mod_exp(alpha, X, q)
def compute_shared_key(Y, X, q):
return mod_exp(Y, X, q)
def alice():
alpha = 10 # Specified value
q = 16 # Specified value
X = int(input("Enter XA for Alice: "))
YA = compute_Y(alpha, X, q)
print(f"YA={YA}")
# Communicate with Dart
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s_dart:
s_dart.connect(('localhost', 5001))
s_dart.send(','.join([str(x) for x in [alpha, X, q, YA]]).encode('utf-8'))
# Receive YD2 from Dart
YD2_dart = int(s_dart.recv(1024).decode('utf-8'))
print(f"Received YD2 from Dart: {YD2_dart}")
# Compute and display K2
K2 = compute_shared_key(YD2_dart, X, q)
print(f"K2={K2}")
if name == "main":
alice()
BOB
import socket
import math
def mod_exp(base, exponent, modulus):
return pow(base, exponent, modulus)
def compute_Y(alpha, X, q):
return mod_exp(alpha, X, q)
def compute_shared_key(Y, X, q):
return mod_exp(Y, X, q)
def bob():
alpha = 10 # Specified value
q = 16 # Specified value
XB = int(input("Enter XB for Bob: "))
YB = compute_Y(alpha, XB, q)
print(f"YB={YB}")
# Communicate with Dart
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s_dart:
s_dart.bind(('localhost', 5002))
s_dart.connect(1)
print("Bob terminal is listening for Dart on port 5002")
conn_dart, addr_dart = s_dart.accept()
with conn_dart:
print(f"Connection established with Dart: {addr_dart}")
# Receive YD1 from Dart
YD1_dart = int(conn_dart.recv(1024).decode('utf-8'))
print(f"Received YD1 from Dart: {YD1_dart}")
# Additional communication with Dart can be added here if needed
# Compute and display K1
K1 = compute_shared_key(YD1_dart, XB, q)
print(f"K1={K1}")
if name == "main":
bob()
DARTH
import socket
import math
def mod_exp(base, exponent, modulus):
return pow(base, exponent, modulus)
def compute_Y(alpha, X, q):
return mod_exp(alpha, X, q)
def compute_k1(YB, XD1, q):
return mod_exp(YB, 5, q)
def compute_k2(YA, XD2, q):
return mod_exp(YA, XD2, q)
def compute_shared_key(Y, X, q):
return mod_exp(Y, X, q)
def dart():
alpha = 15 # Specified value
q = 12 # Specified value
# Communicate with Alice
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s_alice:
s_alice.bind(('localhost', 5001))
s_alice.listen(1)
print("Dart terminal is listening for Alice on port 5001")
conn_alice, addr_alice = s_alice.accept()
with conn_alice:
print(f"Connection established with Alice: {addr_alice}")
data_alice = conn_alice.recv(1024).decode('utf-8')
alpha, X, q, YA = map(int, data_alice.split(','))
print(f"Received data from Alice: alpha={alpha}, X={X}, q={q}, YA={YA}")
XD1 = int(input("Enter XD1: "))
XD2 = int(input("Enter XD2: "))
YD1 = compute_Y(alpha, XD1, q)
YD2 = compute_Y(alpha, XD2, q)
print(f"YD1={YD1}, YD2={YD2}")
K1 = compute_k1(YD1, XD1, q)
K2 = compute_k2(YD2, X, q)
print(f"K1={K1}, K2={K2}")
# Send YD2 to Alice
conn_alice.send(str(YD2).encode('utf-8'))
# Send YD1 to Bob
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s_bob:
s_bob.connect(('localhost', 5002))
s_bob.send(str(YD1).encode('utf-8'))
# Additional communication with Bob can be added here if needed
if name == "main":
dart()
4. MD5
import math
# Define MD5 specific functions
def F(X, Y, Z):
return (X & Y) | (~X & Z)
def G(X, Y, Z):
return (X & Z) | (Y & ~Z)
def H(X, Y, Z):
return X ^ Y ^ Z
def I(X, Y, Z):
return Y ^ (X | ~Z)
# Define shift and constant values
s = [
7, 12, 17, 22,
5, 9, 14, 20,
4, 11, 16, 23,
6, 10, 15, 21
]
K = [int(abs(math.sin(i + 1)) * 2 ** 32) & 0xFFFFFFFF for i in range(64)]
# Initialize variables
A = 0x01234567
B = 0x89ABCDEF
C = 0xFEDCBA98
D = 0x76543210
def md5(message):
global A, B, C, D
message = bytearray(message, 'utf-8')
for i in range(0, len(message), 64):
X = [0] * 16
for j in range(16):
X[j] = int.from_bytes(message[i + j*4:i + j*4 + 4], byteorder='little')
AA, BB, CC, DD = A, B, C, D
# Round 1
for j in range(16):
A = (B + ((A + F(B, C, D) + X[j] + K[j]) & 0xFFFFFFFF) << s[j % 4] | (A + F(B, C, D) + X[j] + K[j]) >> (32 - s[j % 4])) & 0xFFFFFFFF
A, B, C, D = D, A, B, C
print(f"Round 1 - Final Output: {A:08x} {B:08x} {C:08x} {D:08x}")
# Round 2
for j in range(16):
A = (B + ((A + G(B, C, D) + X[(1 + 5*j) % 16] + K[16+j]) & 0xFFFFFFFF) << s[j % 4 + 4] | (A + G(B, C, D) + X[(1 + 5*j) % 16] + K[16+j]) >> (32 - s[j % 4 + 4])) & 0xFFFFFFFF
A, B, C, D = D, A, B, C
print(f"Round 2 - Final Output: {A:08x} {B:08x} {C:08x} {D:08x}")
# Round 3
for j in range(16):
A = (B + ((A + H(B, C, D) + X[(5 + 3*j) % 16] + K[32+j]) & 0xFFFFFFFF) << s[j % 4 + 8] | (A + H(B, C, D) + X[(5 + 3*j) % 16] + K[32+j]) >> (32 - s[j % 4 + 8])) & 0xFFFFFFFF
A, B, C, D = D, A, B, C
print(f"Round 3 - Final Output: {A:08x} {B:08x} {C:08x} {D:08x}")
# Round 4
for j in range(16):
A = (B + ((A + I(B, C, D) + X[(7*j) % 16] + K[48+j]) & 0xFFFFFFFF) << s[j % 4 + 12] | (A + I(B, C, D) + X[(7*j) % 16] + K[48+j]) >> (32 - s[j % 4 + 12])) & 0xFFFFFFFF
A, B, C, D = D, A, B, C
print(f"Round 4 - Final Output: {A:08x} {B:08x} {C:08x} {D:08x}")
A = (A + AA) & 0xFFFFFFFF
B = (B + BB) & 0xFFFFFFFF
C = (C + CC) & 0xFFFFFFFF
D = (D + DD) & 0xFFFFFFFF
digest = bytearray()
for val in (A, B, C, D):
digest.extend(val.to_bytes(4, byteorder='little'))
final_digest = digest * 4 # Concatenate the 128-bit digest four times to get a 512-bit digest
return final_digest.hex()[:32] # Return only the first 32 characters (128 bits) of the digest
# Main function
if name == "main":
message = input("Enter a message to encrypt: ")
digest = md5(message)
print(f"MD5 Digest (128 bits): {digest}")
5. RSA
def gcd(a, b):
while b:
a, b = b, a % b
return a
def mod_inverse(a, m):
m0, x0, x1 = m, 0, 1
while a > 1:
q = a // m
m, a = a % m, m
x0, x1 = x1 - q * x0, x0
return x1 + m0 if x1 < 0 else x1
def generate_keypair(p, q):
n = p * q
totient = (p - 1) * (q - 1)
# Choose e such that 1 < e < totient(n) and gcd(e, totient(n)) = 1
e = 2
while gcd(e, totient) != 1:
e += 1
# Calculate d, the modular multiplicative inverse of e (mod totient(n))
d = mod_inverse(e, totient)
public_key = (e, n)
private_key = (d, n)
print("e:", e)
print("where GCD(e, totient(n)=1)")
return public_key, private_key
def encrypt(message, public_key):
e, n = public_key
return pow(message, e, n)
def decrypt(ciphertext, private_key):
d, n = private_key
return pow(ciphertext, d, n)
# Example input: prime numbers p and q
p = int(input("Enter prime number p: "))
q = int(input("Enter prime number q: "))
# Calculate n and totient
n = p * q
print("n:", n)
totient = (p - 1) * (q - 1)
print("totient(n):", totient)
# Generate key pair
public_key, private_key = generate_keypair(p, q)
# Display public key and private key
print("Public key (e, n):", public_key)
print("Private key (d, n):", private_key)
# Example message to encrypt
message = int(input("Enter message to encrypt: "))
# Encrypt the message
ciphertext = encrypt(message, public_key)
print("Encrypted message (C):", ciphertext)
# Decrypt the message
decrypted_message = decrypt(ciphertext, private_key)
print("Decrypted message (M):", decrypted_message)
# just run, 17, 11, 88
6. SHA
# Initial hash values
a = 0x6A09E667F3BCC908
b = 0xBB67AE8584CAA73B
c = 0x3C6EF372FE94F82B
d = 0xA54FF53A5F1D36F1
e = 0x510E527FADE682D1
f = 0x9B05688C2B3E6C1F
g = 0x1F83D9ABFB41BD6B
h = 0x5BE0CD19137E2179
# Message schedule constants
K = [
0x428A2F98D728AE22, 0x7137449123EF65CD, 0xB5C0FBCFEC4D3B2F, 0xE9B5DBA58189DBBC,
0x3956C25BF348B538, 0x59F111F1B605D019, 0x923F82A4AF194F9B, 0xAB1C5ED5DA6D8118,
0xD807AA98A3030242, 0x12835B0145706FBE, 0x243185BE4EE4B28C, 0x550C7DC3D5FFB4E2,
0x72BE5D74F27B896F, 0x80DEB1FE3B1696B1, 0x9BDC06A725C71235, 0xC19BF174CF692694,
0xE49B69C19EF14AD2, 0xEFBE4786384F25E3, 0x0FC19DC68B8CD5B5, 0x240CA1CC77AC9C65,
0x2DE92C6F592B0275, 0x4A7484AA6EA6E483, 0x5CB0A9DCBD41FBD4, 0x76F988DA831153B5,
0x983E5152EE66DFAB, 0xA831C66D2DB43210, 0xB00327C898FB213F, 0xBF597FC7BEEF0EE4,
0xC6E00BF33DA88FC2, 0xD5A79147930AA725, 0x06CA6351E003826F, 0x142929670A0E6E70,
0x27B70A8546D22FFC, 0x2E1B21385C26C926, 0x4D2C6DFC5AC42AED, 0x53380D139D95B3DF,
0x650A73548BAF63DE, 0x766A0ABB3C77B2A8, 0x81C2C92E47EDAEE6, 0x92722C851482353B,
0xA2BFE8A14CF10364, 0xA81A664BBC423001, 0xC24B8B70D0F89791, 0xC76C51A30654BE30,
0xD192E819D6EF5218, 0xD69906245565A910, 0xF40E35855771202A, 0x106AA07032BBD1B8,
0x19A4C116B8D2D0C8, 0x1E376C085141AB53, 0x2748774CDF8EEB99, 0x34B0BCB5E19B48A8,
0x391C0CB3C5C95A63, 0x4ED8AA4AE3418ACB, 0x5B9CCA4F7763E373, 0x682E6FF3D6B2B8A3,
0x748F82EE5DEFB2FC, 0x78A5636F43172F60, 0x84C87814A1F0AB72, 0x8CC702081A6439EC,
0x90BEFFFA23631E28, 0xA4506CEBDE82BDE9, 0xBEF9A3F7B2C67915, 0xC67178F2E372532B,
0xCA273ECEEA26619C, 0xD186B8C721C0C207, 0xEADA7DD6CDE0EB1E, 0xF57D4F7FEE6ED178,
0x06F067AA72176FBA, 0x0A637DC5A2C898A6, 0x113F9804BEF90DAE, 0x1B710B35131C471B,
0x28DB77F523047D84, 0x32CAAB7B40C72493, 0x3C9EBE0A15C9BEBC, 0x431D67C49C100D4C,
0x4CC5D4BECB3E42B6, 0x597F299CFC657E2A, 0x5FCB6FAB3AD6FAEC, 0x6C44198C4A475817,
]
# Initial message schedule
W = [0] * 80
# Get user input for the message
message = input("Enter the message: ").encode('utf-8')
bit_len = len(message) * 8
message += b'\x80'
while (len(message) + 8) % 128 != 0:
message += b'\x00'
message += bit_len.to_bytes(8, 'big')
# Process the message in blocks of 1024 bits
for i in range(0, len(message), 128):
block = message[i:i+128]
# Break the block into 64 64-bit words
for j in range(16):
W[j] = int.from_bytes(block[j*8:(j+1)*8], 'big')
# Extend the 16 64-bit words into 80 64-bit words
for j in range(16, 80):
s0 = (W[j-15] >> 19 | W[j-15] << 63) ^ (W[j-15] >> 8 | W[j-15] << 56) ^ (W[j-15] >> 7)
s1 = (W[j-2] >> 1 | W[j-2] << 45) ^ (W[j-2] >> 61 | W[j-2] << 3) ^ (W[j-2] >> 6)
W[j] = (W[j-16] + s0 + W[j-7] + s1) & 0xFFFFFFFFFFFFFFFF
# Initialize working variables
a, b, c, d, e, f, g, h = a, b, c, d, e, f, g, h
# Main loop
for j in range(80):
s0 = (a >> 28 | a << 36) ^ (a >> 34 | a << 30) ^ (a >> 39 | a << 25)
s1 = (e >> 14 | e << 50) ^ (e >> 18 | e << 26) ^ (e >> 41 | e << 23)
ch = (e & f) ^ (~e & g)
maj = (a & b) ^ (a & c) ^ (b & c)
temp1 = h + s1 + ch + K[j] + W[j]
temp2 = s0 + maj
h = g
g = f
f = e
e = (d + temp1) & 0xFFFFFFFFFFFFFFFF
d = c
c = b
b = a
a = (temp1 + temp2) & 0xFFFFFFFFFFFFFFFF
# Print values for each word and round
print(f"w{j+1:02} = {W[j]:016X} Round {j+1}: a = {a:016X} b = {b:016X} c = {c:016X} d = {d:016X} e = {e:016X} f = {f:016X} g = {g:016X} h = {h:016X}\n")
print("new block")
# Print the final hash value
hash_result = (a, b, c, d, e, f, g, h)
final_hash = ''.join(format(word, '016X') for word in hash_result)
print(f"Final Hash/Message Digest (512 bits): {final_hash}")
7. DSS
import socket
import struct
def sha1(message):
# Initialize variables
h0 = 0x67452301
h1 = 0xEFCDAB89
h2 = 0x98BADCFE
h3 = 0x10325476
h4 = 0xC3D2E1F0
# Pre-processing
original_message = message
message = bytearray(message, 'utf-8')
ml = len(original_message) * 8 # Length of original message in bits
message.append(0x80) # Append bit '1' to the message
while len(message) % 64 != 56:
message.append(0x00) # Append bits '0' to the message until message length is 64 bits less than multiple of 512
message += struct.pack('>Q', ml) # Append original message length in bits as 64-bit big-endian integer
# Process message in 512-bit chunks
for i in range(0, len(message), 64):
chunk = message[i:i+64]
# Break chunk into sixteen 32-bit big-endian words
words = [0] * 80
for j in range(16):
words[j] = struct.unpack('>I', chunk[j*4:j*4+4])[0]
# Extend the sixteen 32-bit words into eighty 32-bit words
for j in range(16, 80):
words[j] = left_rotate(words[j-3] ^ words[j-8] ^ words[j-14] ^ words[j-16], 1)
# Initialize hash value for this chunk
a = h0
b = h1
c = h2
d = h3
e = h4
# Main loop
for j in range(80):
if j < 20:
f = (b & c) | ((~b) & d)
k = 0x5A827999
elif 20 <= j < 40:
f = b ^ c ^ d
k = 0x6ED9EBA1
elif 40 <= j < 60:
f = (b & c) | (b & d) | (c & d)
k = 0x8F1BBCDC
else:
f = b ^ c ^ d
k = 0xCA62C1D6
temp = left_rotate(a, 5) + f + e + k + words[j] & 0xFFFFFFFF
e = d
d = c
c = left_rotate(b, 30)
b = a
a = temp
# Add this chunk's hash to result so far
h0 = (h0 + a) & 0xFFFFFFFF
h1 = (h1 + b) & 0xFFFFFFFF
h2 = (h2 + c) & 0xFFFFFFFF
h3 = (h3 + d) & 0xFFFFFFFF
h4 = (h4 + e) & 0xFFFFFFFF
# Produce the final hash value
return '%08x%08x%08x%08x%08x' % (h0, h1, h2, h3, h4)
def left_rotate(n, d):
return ((n << d) | (n >> (32 - d))) & 0xFFFFFFFF
def calculate_values(p, q, g, k, hm, x):
# Calculate y
y = pow(g, x, p)
# Calculate r
r = pow(g, k, p) % q
# Calculate s
k_inverse = pow(k, -1, q)
s = (k_inverse * (int(hm, 16) + x * r)) % q
# Calculate w
w = pow(s, -1, q)
# Calculate u1 and u2
u1 = (int(hm, 16) * w) % q
u2 = (r * w) % q
# Calculate v
v = (pow(g, u1, p) * pow(y, u2, p)) % p % q
return y, r, s, w, u1, u2, v
def main():
# Client configuration
host = '127.0.0.1'
port = 12345
# Create a socket object
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connect to the server
client_socket.connect((host, port))
# Gather inputs from the user
p = int(input("Enter the value of p: "))
q = int(input("Enter the value of q: "))
g = int(input("Enter the value of g: "))
k = int(input("Enter the value of k (User's per-Message Secret Number): "))
message = input("Enter the message: ")
# Calculate hash value (SHA-1)
hm = sha1(message)
print(f"The hash value of {message} (SHA-1): {hm}")
x = int(input("Enter the value of x (User's Private Key): "))
# Calculate values
y, r, s, w, u1, u2, v = calculate_values(p, q, g, k, hm, x)
# Print signature
print(f"Signature: [r:{r},s:{s}]")
# Ask user if they want to send the correct message
send_correct = input("Do you want to send the correct message? (y/n): ")
if send_correct.lower() == 'y':
correct_message = input("Enter the correct message: ")
correct_hm = sha1(correct_message)
print(f"The hash value of {correct_message} (SHA-1): {correct_hm}")
# Calculate u1 for correct message
correct_u1 = (int(correct_hm, 16) * w) % q
# Calculate v for correct message
correct_v = (pow(g, correct_u1, p) * pow(y, u2, p)) % p % q
# Send correct message values to the server
data = f"{p},{q},{g},{k},{correct_hm},{x},{y},{r},{s},{w},{correct_u1},{u2},{correct_v}"
else:
# Send original message values to the server
data = f"{p},{q},{g},{k},{hm},{x},{y},{r},{s},{w},{u1},{u2},{v}"
print("Data Sent successfully to the Client")
# Send inputs and calculated values to the server
client_socket.send(data.encode())
# Close the connection
client_socket.close()
if _name_ == "_main_":
main()
import socket
def main():
# Server configuration
host = '127.0.0.1'
port = 12345
# Create a socket object
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Bind the socket to the address
server_socket.bind((host, port))
# Listen for incoming connections
server_socket.listen(1)
print("Server is listening on port", port)
# Accept a connection
client_socket, addr = server_socket.accept()
print("Connection from", addr)
# Receive data from the client
data = client_socket.recv(1024).decode()
print("Received data from server:", data)
# Split received data into individual values
values = data.split(',')
# Display received values
print("Received values from server:")
print("p:", values[0])
print("q:", values[1])
print("g:", values[2])
print("k:", values[3])
print("hm:", values[4])
print("x:", values[5])
print("y:", values[6])
print("s:", values[8])
print("\n")
print("Verification:")
print("w:", values[9])
print("u1:", values[10])
print("u2:", values[11])
print("v:", values[12])
print("\n")
print("r' (from sender):", values[7])
print("v (calculated):", values[12])
# Perform DSS verification
r = int(values[8])
v = int(values[11])
if v == r:
print("Digital Signature Standard (DSS) verification Successful")
else:
print("Digital Signature Standard (DSS) Verification Failed")
# Close the connection
client_socket.close()
if _name_ == "_main_":
main()

Editor

You can edit this paste and save as new:

fullscreen copy clear

Syntax Highlighting

Title / Paste Name

Meta robots tag

reCaptcha

File Description

sys
Paste Code
30 Apr-2024
60.32 Kb

You can Share it:

Latest Code Pastes

Full list

Tools

[text] sys

Viewer

Editor