# Untitled

unknown
plain_text
2 years ago
16 kB
1
Indexable
Never
```//ecludean algo
#include<stdio.h>
#include<conio.h>

int main()
{
int a, b, q, r, t;

printf("Enter number a: ");
scanf("%d", &a);
printf("Enter number b: ");
scanf("%d", &b);
// large case
if (b>a)
{
t = a;
a = b;
b = t;
}
printf("q\ta\tb\tr\n");

do
{
q = a/b;
r = a%b;
printf("%d\t%d\t%d\t%d\n", q, a, b, r);
a = b;
b = r;
if(b==0)
{
printf("%d\t%d\t%d\t%d\n", q, a, b, r);
}
}while(b!=0);

printf("GCD = %d", a);
getch();
return 0;
}

//extended ecludean
#include<stdio.h>
#include<conio.h>

int main()
{
int a, b, q, r, temp, s1=1, s2=0, s, t1=0, t2=1, t, N;

printf("Enter number a: ");
scanf("%d", &a);
printf("Enter number b: ");
scanf("%d", &b);

// large case
if (b>a)
{
temp = a;
a = b;
b = temp;
}

N = a;

printf("q\ta\tb\tr\ts1\ts2\ts\tt1\tt2\tt\n");

do
{
q = a/b;
r = a%b;
s = s1 - q*s2;
t = t1 - q*t2;
printf("%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n", q, a, b, r, s1, s2, s, t1, t2, t);

a = b;
b = r;

s1 = s2;
s2 = s;

t1 = t2;
t2 = t;

if(b==0)
{
printf("%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n", q, a, b, r, s1, s2, s, t1, t2, t);
}
}while(b!=0);

printf("GCD = %d\n", a);

//multiplicative inverse (t1)
t1>0 ? printf("Multiplicative inverse: %d", t1): printf("Multiplicative inverse: %d", t1+N);

getch();
return 0;
}

//diffe hellman
#include<stdio.h>
#include<conio.h>
#include<math.h>
// global parameter
int p = 11, g = 2;
int a, b;

int main()
{
int x, y, ssk1, ssk2;

printf("Alice Choice: ");
scanf("%d", &x);
printf("Bob Choice: ");
scanf("%d", &y);
// Alice
a = (long int) pow(g, x) % p;
// Bob
b = (long int) pow(g, y) % p;

// SSK for ALICE
ssk1 = (long int) pow(b, x) % p;
// SSK for BOB
ssk2 = (long int) pow(a, y) % p;
printf("SSK1 = %d and SSK2 = %d", ssk1, ssk2);
getch();
return 0;
}

//rsa
#include<stdio.h>
#include<conio.h>
#include<math.h>
// 1. select p and q
// 2. n = p*q
// 3. phi = (p-1)*(q-1)
// 4. choose public key e such that 1<e<phi, gcd(e, phi)=1

// 5. calculate privat key: e*d = 1 mod phi

// 6. Encryption: c = m^e mod n -- m message, c cipher
// 7. Decryption: m = c^d mod n

long long int p = 7, q = 11;

long long int gcd(long long int, long long int);
//long int mypow(long int, long int);

int main()
{
long long int n, phi, e, d;
long long int m = 2, c;

//2
n = p*q; // 77

//3 Euler toitent function
phi = (p-1)*(q-1);  // 60

//4. choose public key
p:
printf("Enter public component: ");
scanf("%lld", &e);  // 13

// range 1<e<phi, gcd(e,phi)==1
// printf("GCD = %ld", gcd(phi, e));
// printf("GCD = %ld\n", gcd(phi, e));

if(!(e>1 && e<phi && gcd(phi,e)==1))
{
printf("Public component is not selected properly.\n");
goto p;
}

//printf("Okay!");

// 5 find private key e * d = 1 mod phi

// Simple searching strategy
// In real implementation use proper algorithm.
d = 2;
while(e*d % phi != 1)
{
// printf("checking = %ld\n", d);
d++;
}

printf("\nPrivate Key = %ld\n", d);

// 6. Encryption

//printf("\nm^e = %lld\n", (long long int) pow(m, e));

c = (long long int) pow(m, e) % n;
printf("\nCipher: %lld\n", c);

// 7. Decryption
//printf("\nc^d = %lld\n", (long int)pow(c,d));

m = (long long int) pow(c, d) % n;
printf("\nPlain: %lld\n", m);

getch();
return 0;
}

long long int gcd(long long int a, long long int b)
{
long long int q, r, tmp;
/* use if required*/

if (b>a)
{
tmp = a;
a = b;
b = tmp;
}

while (b!=0)
{
q = a/b;
r = a%b;
a = b;
b = r;
}
return a;
}

/*
long int mypow(long int a, long int b)
{
long int p=1, i;
for(i=1;i<b;i++)
{
p *= a;
}
return p;
}
*/

//millerrabin
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/*
* calculates (a * b) % c taking into account that a * b might overflow
*/
long long mulmod(long long a, long long b, long long mod)
{
long long x = 0,y = a % mod;
while (b > 0)
{
if (b % 2 == 1)
{
x = (x + y) % mod;
}
y = (y * 2) % mod;
b /= 2;
}
return x % mod;
}
/*
* modular exponentiation
*/
long long modulo(long long base, long long exponent, long long mod)
{
long long x = 1;
long long y = base;
while (exponent > 0)
{
if (exponent % 2 == 1)
x = (x * y) % mod;
y = (y * y) % mod;
exponent = exponent / 2;
}
return x % mod;
}

/*
* Miller-Rabin Primality test, iteration signifies the accuracy
*/
int Miller(long long p,int iteration)
{

int i;
long long s;
if (p < 2)
{
return 0;
}
if (p != 2 && p % 2==0)
{
return 0;
}
s = p - 1;
while (s % 2 == 0)
{
s /= 2;
}
for (i = 0; i < iteration; i++)
{
long long a = rand() % (p - 1) + 1, temp = s;
long long mod = modulo(a, temp, p);
while (temp != p - 1 && mod != 1 && mod != p - 1)
{
mod = mulmod(mod, mod, p);
temp *= 2;
}
if (mod != p - 1 && temp % 2 == 0)
{
return 0;
}
}
return 1;
}
//Main
int main()
{
int iteration = 5;
long long num;
printf("Enter integer to test primality: ");
scanf("%lld", &num);
if ( Miller( num, iteration))
printf("\n%lld is prime\n", num);
else
printf("\n%lld is not prime\n", num);
return 0;
}

//elgamal
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int is_prime(int num) {
int i;
for (i = 2; i <= sqrt(num); i++) {
if (num % i == 0) {
return 0;
}
}
return 1;
}

int generate_prime(int min, int max) {
int num = min + rand() % (max - min);
while (!is_prime(num)) {
num++;
}
return num;
}

int power(int a, int b, int p) {
int result = 1;
while (b > 0) {
if (b % 2 == 1) {
result = (result * a) % p;
}
a = (a * a) % p;
b /= 2;
}
return result;
}

int main() {
int p, g, x, y, k, m, r, e, d;

printf("Enter a prime number p: ");
scanf("%d", &p);

while (!is_prime(p)) {
printf("p is not prime. Enter a prime number p: ");
scanf("%d", &p);
}

printf("Enter a generator g: ");
scanf("%d", &g);

//    while (g <= 1 || g >= p - 1 || power(g, (p - 1) / 2, p) != 1) {
//        printf("g is not a generator. Enter a generator g: ");
//        scanf("%d", &g);
//    }

printf("Enter a private key x: ");
scanf("%d", &x);

printf("Enter a message m: ");
scanf("%d", &m);

y = power(g,x,p);
k = generate_prime(2, p - 2);
r = power(g, k, p);
e = (m * power(y, k, p)) % p;
d = (e * power(r, p - 1 - x, p)) % p;

printf("Public key (p, g, y) = (%d, %d, %d)\n", p, g, y);
printf("Private key x = %d\n", x);
printf("Message m = %d\n", m);
printf("Random integer k = %d\n", k);
printf("Encrypted message (r, e) = (%d, %d)\n", r, e);
printf("Decrypted message d = %d\n", d);

return 0;
}

//hill cipher
#include<stdio.h>
#include<string.h>
int main() {
unsigned int a[3][3] = { { 6, 24, 1 }, { 13, 16, 10 }, { 20, 17, 15 } };
unsigned int b[3][3] = { { 8, 5, 10 }, { 21, 8, 21 }, { 21, 12, 8 } };
int i, j;
unsigned int c[20], d[20];
char msg[20];
int determinant = 0, t = 0;
;
printf("Enter plain text\n ");
scanf("%s", msg);
for (i = 0; i < 3; i++) {
c[i] = msg[i] - 65;
printf("%d ", c[i]);
}
for (i = 0; i < 3; i++) {
t = 0;
for (j = 0; j < 3; j++) {
t = t + (a[i][j] * c[j]);
}
d[i] = t % 26;
}
printf("\nEncrypted Cipher Text :");
for (i = 0; i < 3; i++)
printf(" %c", d[i] + 65);
for (i = 0; i < 3; i++) {
t = 0;
for (j = 0; j < 3; j++) {
t = t + (b[i][j] * d[j]);
}
c[i] = t % 26;
}
printf("\nDecrypted Cipher Text :");
for (i = 0; i < 3; i++)
printf(" %c", c[i] + 65);
return 0;
}

//vignere cipher
#include<stdio.h>
#include<string.h>

int main(){
char msg[] = "THECRAZYPROGRAMMER";
char key[] = "HELLO";
int msgLen = strlen(msg), keyLen = strlen(key), i, j;

char newKey[msgLen], encryptedMsg[msgLen], decryptedMsg[msgLen];

//generating new key
for(i = 0, j = 0; i < msgLen; ++i, ++j){
if(j == keyLen)
j = 0;

newKey[i] = key[j];
}

newKey[i] = '\0';

//encryption
for(i = 0; i < msgLen; ++i)
encryptedMsg[i] = ((msg[i] + newKey[i]) % 26) + 'A';

encryptedMsg[i] = '\0';

//decryption
for(i = 0; i < msgLen; ++i)
decryptedMsg[i] = (((encryptedMsg[i] - newKey[i]) + 26) % 26) + 'A';

decryptedMsg[i] = '\0';

printf("Original Message: %s", msg);
printf("\nKey: %s", key);
printf("\nNew Generated Key: %s", newKey);
printf("\nEncrypted Message: %s", encryptedMsg);
printf("\nDecrypted Message: %s", decryptedMsg);

return 0;
}

//caesar cipher
#include<stdio.h>

int main()
{
char message[100], ch;
int i, key;
printf("Enter a message to encrypt: ");
gets(message);
printf("Enter key: ");
scanf("%d", &key);
for(i = 0; message[i] != '\0'; ++i){
ch = message[i];
if(ch >= 'a' && ch <= 'z'){
ch = ch + key;
if(ch > 'z'){
ch = ch - 'z' + 'a' - 1;
}
message[i] = ch;
}
else if(ch >= 'A' && ch <= 'Z'){
ch = ch + key;
if(ch > 'Z'){
ch = ch - 'Z' + 'A' - 1;
}
message[i] = ch;
}
}
printf("Encrypted message: %s", message);
return 0;
}
//decrypt
#include<stdio.h>

int main()
{
char message[100], ch;
int i, key;
printf("Enter a message to decrypt: ");
gets(message);
printf("Enter key: ");
scanf("%d", &key);
for(i = 0; message[i] != '\0'; ++i){
ch = message[i];
if(ch >= 'a' && ch <= 'z'){
ch = ch - key;
if(ch < 'a'){
ch = ch + 'z' - 'a' + 1;
}
message[i] = ch;
}
else if(ch >= 'A' && ch <= 'Z'){
ch = ch - key;
if(ch < 'A'){
ch = ch + 'Z' - 'A' + 1;
}
message[i] = ch;
}
}
printf("Decrypted message: %s", message);
return 0;
}

//playfair cipher
// C program to implement Playfair Cipher

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZE 30

// Function to convert the string to lowercase
void toLowerCase(char plain[], int ps)
{
int i;
for (i = 0; i < ps; i++) {
if (plain[i] > 64 && plain[i] < 91)
plain[i] += 32;
}
}

// Function to remove all spaces in a string
int removeSpaces(char* plain, int ps)
{
int i, count = 0;
for (i = 0; i < ps; i++)
if (plain[i] != ' ')
plain[count++] = plain[i];
plain[count] = '\0';
return count;
}

// Function to generate the 5x5 key square
void generateKeyTable(char key[], int ks, char keyT[5][5])
{
int i, j, k, flag = 0, *dicty;

// a 26 character hashmap
// to store count of the alphabet
dicty = (int*)calloc(26, sizeof(int));
for (i = 0; i < ks; i++) {
if (key[i] != 'j')
dicty[key[i] - 97] = 2;
}

dicty['j' - 97] = 1;

i = 0;
j = 0;

for (k = 0; k < ks; k++) {
if (dicty[key[k] - 97] == 2) {
dicty[key[k] - 97] -= 1;
keyT[i][j] = key[k];
j++;
if (j == 5) {
i++;
j = 0;
}
}
}

for (k = 0; k < 26; k++) {
if (dicty[k] == 0) {
keyT[i][j] = (char)(k + 97);
j++;
if (j == 5) {
i++;
j = 0;
}
}
}
}

// Function to search for the characters of a digraph
// in the key square and return their position
void search(char keyT[5][5], char a, char b, int arr[])
{
int i, j;

if (a == 'j')
a = 'i';
else if (b == 'j')
b = 'i';

for (i = 0; i < 5; i++) {

for (j = 0; j < 5; j++) {

if (keyT[i][j] == a) {
arr[0] = i;
arr[1] = j;
}
else if (keyT[i][j] == b) {
arr[2] = i;
arr[3] = j;
}
}
}
}

// Function to find the modulus with 5
int mod5(int a) { return (a % 5); }

// Function to make the plain text length to be even
int prepare(char str[], int ptrs)
{
if (ptrs % 2 != 0) {
str[ptrs++] = 'z';
str[ptrs] = '\0';
}
return ptrs;
}

// Function for performing the encryption
void encrypt(char str[], char keyT[5][5], int ps)
{
int i, a[4];

for (i = 0; i < ps; i += 2) {

search(keyT, str[i], str[i + 1], a);

if (a[0] == a[2]) {
str[i] = keyT[a[0]][mod5(a[1] + 1)];
str[i + 1] = keyT[a[0]][mod5(a[3] + 1)];
}
else if (a[1] == a[3]) {
str[i] = keyT[mod5(a[0] + 1)][a[1]];
str[i + 1] = keyT[mod5(a[2] + 1)][a[1]];
}
else {
str[i] = keyT[a[0]][a[3]];
str[i + 1] = keyT[a[2]][a[1]];
}
}
}

// Function to encrypt using Playfair Cipher
void encryptByPlayfairCipher(char str[], char key[])
{
char ps, ks, keyT[5][5];

// Key
ks = strlen(key);
ks = removeSpaces(key, ks);
toLowerCase(key, ks);

// Plaintext
ps = strlen(str);
toLowerCase(str, ps);
ps = removeSpaces(str, ps);

ps = prepare(str, ps);

generateKeyTable(key, ks, keyT);

encrypt(str, keyT, ps);
}

// Driver code
int main()
{
char str[SIZE], key[SIZE];

// Key to be encrypted
strcpy(key, "Monarchy");
printf("Key text: %s\n", key);

// Plaintext to be encrypted
strcpy(str, "instruments");
printf("Plain text: %s\n", str);

// encrypt using Playfair Cipher
encryptByPlayfairCipher(str, key);

printf("Cipher text: %s\n", str);

return 0;
}

//rail fence cipher
#include<stdio.h>
#include<string.h>

void encryptMsg(char msg[], int key){
int msgLen = strlen(msg), i, j, k = -1, row = 0, col = 0;
char railMatrix[key][msgLen];

for(i = 0; i < key; ++i)
for(j = 0; j < msgLen; ++j)
railMatrix[i][j] = '\n';

for(i = 0; i < msgLen; ++i){
railMatrix[row][col++] = msg[i];

if(row == 0 || row == key-1)
k= k * (-1);

row = row + k;
}

printf("\nEncrypted Message: ");

for(i = 0; i < key; ++i)
for(j = 0; j < msgLen; ++j)
if(railMatrix[i][j] != '\n')
printf("%c", railMatrix[i][j]);
}

void decryptMsg(char enMsg[], int key){
int msgLen = strlen(enMsg), i, j, k = -1, row = 0, col = 0, m = 0;
char railMatrix[key][msgLen];

for(i = 0; i < key; ++i)
for(j = 0; j < msgLen; ++j)
railMatrix[i][j] = '\n';

for(i = 0; i < msgLen; ++i){
railMatrix[row][col++] = '*';

if(row == 0 || row == key-1)
k= k * (-1);

row = row + k;
}

for(i = 0; i < key; ++i)
for(j = 0; j < msgLen; ++j)
if(railMatrix[i][j] == '*')
railMatrix[i][j] = enMsg[m++];

row = col = 0;
k = -1;

printf("\nDecrypted Message: ");

for(i = 0; i < msgLen; ++i){
printf("%c", railMatrix[row][col++]);

if(row == 0 || row == key-1)
k= k * (-1);

row = row + k;
}
}

int main(){
char msg[] = "Hello World";
char enMsg[] = "Horel ollWd";
int key = 3;

printf("Original Message: %s", msg);

encryptMsg(msg, key);
decryptMsg(enMsg, key);

return 0;
}

```