Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Upload

Welcome to Scribd!

  • 4 views

    IS pr-1 To 8

    Uploaded by

    Darshan Bhavsar
    It is practical of is

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd

    IS pr-1 To 8

    Uploaded by

    Darshan Bhavsar
    4 views14 pages
    It is practical of is

    Original Title

    IS pr-1 to 8

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    It is practical of is

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    4 views14 pages

    IS pr-1 To 8

    Uploaded by

    Darshan Bhavsar
    It is practical of is

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 14

    Practical-1

    #include <stdio.h>

    void caesarCipher(char *text, int shift) {


    int i;

    for (i = 0; text[i] != '\0'; i++) {


    if (text[i] >= 'A' && text[i] <= 'Z') {
    text[i] = (text[i] - 'A' + shift) % 26 + 'A';
    } else if (text[i] >= 'a' && text[i] <= 'z') {
    text[i] = (text[i] - 'a' + shift) % 26 + 'a';
    }
    }
    }

    int main() {
    char text[100];
    int shift;

    printf("Enter the text: ");


    fgets(text, 100, stdin);

    printf("Enter the shift: ");


    scanf("%d", &shift);

    caesarCipher(text, shift);
    printf("Encrypted text: %s\n", text);

    return 0;
    }

    Output:
    Enter the text: testing project
    Enter the shift: 4
    Encrypted text: xiwxmrk tvsnigx
    Practical-2

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

    void monoalphabetic_cipher(char *text, char *key) {


    int i, j;
    char sub_table[26];

    // Create the substitution table


    for (i = 0; i < 26; i++) {
    sub_table[i] = key[i];
    }

    for (i = 0; text[i] != '\0'; i++) {


    if (isalpha(text[i])) {
    if (isupper(text[i])) {
    text[i] = sub_table[text[i] - 'A'];
    } else {
    text[i] = sub_table[text[i] - 'a'] + 'a';
    }
    }
    }
    }

    int main() {
    char text[] = "hello world";
    char key[] = "bcdefghijklmnopqrstuvwxyz";

    monoalphabetic_cipher(text, key);
    printf("Encrypted text: %s\n", text);

    // Decryption is the same as encryption with the same key


    monoalphabetic_cipher(text, key);
    printf("Decrypted text: %s\n", text);
    return 0;
    }

    Output:
    Encrypted text: ifmmp xpsme
    Decrypted text: hello world

    Practical-3

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

    void vigenere_cipher(char *text, char *keyword) {


    int i, j;
    int keyword_len = strlen(keyword);

    for (i = 0; text[i] != '\0'; i++) {


    if (isalpha(text[i])) {
    int shift = tolower(keyword[i % keyword_len]) - 'a';
    if (isupper(text[i])) {
    text[i] = (text[i] - 'A' + shift) % 26 + 'A';
    } else {
    text[i] = (text[i] - 'a' + shift) % 26 + 'a';
    }
    }
    }
    }

    int main() {
    char text[] = "hello world";
    char key[] = "key";

    vigenere_cipher(text, key);
    printf("Encrypted text: %s\n", text);
    // Decryption is the same as encryption with the same key
    vigenere_cipher(text, key);
    printf("Decrypted text: %s\n", text);

    return 0;
    }

    Output:
    Encrypted text: lpkmc qvzy
    Decrypted text: hello world

    Practical-4

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

    #define MATRIX_SIZE 5

    // Function to remove duplicates and prepare the Playfair key matrix


    void prepare_key_matrix(const char *key, char
    matrix[MATRIX_SIZE][MATRIX_SIZE]) {
    int seen[26] = {0};
    int i, j = 0, k = 0;
    char c;

    // Fill the matrix with key and remaining letters


    for (i = 0; key[i] != '\0'; i++) {
    c = toupper(key[i]);
    if (c == 'J') c = 'I';
    if (isalpha(c) && !seen[c - 'A']) {
    matrix[j / MATRIX_SIZE][j % MATRIX_SIZE] = c;
    seen[c - 'A'] = 1;
    j++;
    }
    }
    for (i = 0; i < 26; i++) {
    c = 'A' + i;
    if (c == 'J') continue; // Skip 'J'
    if (!seen[i]) {
    matrix[j / MATRIX_SIZE][j % MATRIX_SIZE] = c;
    j++;
    }
    }
    }

    // Function to find the position of a letter in the matrix


    void find_position(char matrix[MATRIX_SIZE][MATRIX_SIZE], char c, int *row,
    int *col) {
    if (c == 'J') c = 'I'; // Treat 'J' as 'I'
    for (int i = 0; i < MATRIX_SIZE; i++)
    for (int j = 0; j < MATRIX_SIZE; j++)
    if (matrix[i][j] == c) {
    *row = i;
    *col = j;
    return;
    }
    }

    // Encrypt a digraph (pair of letters)


    void encrypt_pair(char matrix[MATRIX_SIZE][MATRIX_SIZE], char a, char b,
    char *encrypted_pair) {
    int row_a, col_a, row_b, col_b;
    find_position(matrix, a, &row_a, &col_a);
    find_position(matrix, b, &row_b, &col_b);

    if (row_a == row_b) {
    // Same row
    encrypted_pair[0] = matrix[row_a][(col_a + 1) % MATRIX_SIZE];
    encrypted_pair[1] = matrix[row_b][(col_b + 1) % MATRIX_SIZE];
    } else if (col_a == col_b) {
    // Same column
    encrypted_pair[0] = matrix[(row_a + 1) % MATRIX_SIZE][col_a];
    encrypted_pair[1] = matrix[(row_b + 1) % MATRIX_SIZE][col_b];
    } else {
    // Rectangle rule
    encrypted_pair[0] = matrix[row_a][col_b];
    encrypted_pair[1] = matrix[row_b][col_a];
    }
    }

    // Function to encrypt the entire text


    void encrypt_text(const char *plaintext, char *ciphertext, char
    matrix[MATRIX_SIZE][MATRIX_SIZE]) {
    char digraph[3] = {0};
    int len = strlen(plaintext), i, j = 0;

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


    char a = toupper(plaintext[i]);
    char b = (i + 1 < len) ? toupper(plaintext[i + 1]) : 'X';
    if (a == b) b = 'X'; // Handle repeated letters
    encrypt_pair(matrix, a, b, digraph);
    ciphertext[j++] = digraph[0];
    ciphertext[j++] = digraph[1];
    }
    ciphertext[j] = '\0';
    }

    int main() {
    char key[100], plaintext[100], ciphertext[100];
    char matrix[MATRIX_SIZE][MATRIX_SIZE];

    printf("Enter the key: ");


    scanf("%s", key);

    printf("Enter the plaintext: ");


    scanf("%s", plaintext);

    prepare_key_matrix(key, matrix);
    encrypt_text(plaintext, ciphertext, matrix);
    printf("Encrypted text: %s\n", ciphertext);

    return 0;
    }

    Output:
    Enter the key: monarchy
    Enter the plaintext: hidegold
    Encrypted text: BFCKFNTC

    Practical-5

    #include <stdio.h>

    // Function to encrypt the message using the Hill Cipher


    void encrypt(int keyMatrix[2][2], char message[3], char cipherText[3]) {
    int messageVector[2];
    int cipherMatrix[2];

    // Convert characters to numbers (A=0, B=1, ..., Z=25)


    for (int i = 0; i < 2; i++) {
    messageVector[i] = message[i] - 'A';
    }

    // Encrypt using matrix multiplication


    for (int i = 0; i < 2; i++) {
    cipherMatrix[i] = 0;
    for (int j = 0; j < 2; j++) {
    cipherMatrix[i] += keyMatrix[i][j] * messageVector[j];
    }
    cipherMatrix[i] = cipherMatrix[i] % 26; // Mod 26 for letters
    }

    // Convert back to characters


    for (int i = 0; i < 2; i++) {
    cipherText[i] = cipherMatrix[i] + 'A';
    }
    cipherText[2] = '\0'; // Null-terminate the string
    }

    int main() {
    // 2x2 key matrix
    int keyMatrix[2][2] = {{3, 3},
    {2, 5}};

    // Message to be encrypted (2 characters)


    char message[3] = "HI"; // Example message
    char cipherText[3]; // To store the encrypted message

    // Encrypt the message


    encrypt(keyMatrix, message, cipherText);

    // Display the encrypted message


    printf("Encrypted Text: %s\n", cipherText);

    return 0;
    }

    Output:
    Encrypted Text: TC

    Practical-6

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

    void columnar_transposition(char *plaintext, char *keyword, char *ciphertext)


    {
    int rows = strlen(keyword);
    int cols = strlen(plaintext) / rows + (strlen(plaintext) % rows > 0 ? 1 : 0);

    // Create a grid
    char grid[rows][cols];

    // Fill the grid with plaintext


    int index = 0;
    for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
    if (index < strlen(plaintext)) {
    grid[i][j] = plaintext[index++];
    } else {
    grid[i][j] = ' '; // Pad with spaces if necessary
    }
    }
    }

    // Determine column order based on keyword


    int order[rows];
    for (int i = 0; i < rows; i++) {
    order[i] = i;
    }
    for (int i = 0; i < rows - 1; i++) {
    for (int j = i + 1; j < rows; j++) {
    if (keyword[order[i]] > keyword[order[j]]) {
    int temp = order[i];
    order[i] = order[j];
    order[j] = temp;
    }
    }
    }

    // Read the grid column-wise in the specified order


    index = 0;
    for (int j = 0; j < cols; j++) {
    for (int i = 0; i < rows; i++) {
    ciphertext[index++] = grid[i][order[j]];
    }
    }
    ciphertext[index] = '\0';
    }

    int main() {
    char plaintext[] = "meet me at the park at midnight";
    char keyword[] = "secret";
    char ciphertext[100];

    columnar_transposition(plaintext, keyword, ciphertext);

    printf("Ciphertext: %s\n", ciphertext);

    return 0;
    }

    Output:
    Ciphertext: ea an e e d a g ttpti mehkitmtrmh

    Practical-7

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

    // Function to compute gcd


    int gcd(int a, int b) {
    while (b != 0) {
    int t = b;
    b = a % b;
    a = t;
    }
    return a;
    }

    // Function to find modular inverse


    int mod_inverse(int a, int m) {
    for (int x = 1; x < m; x++) {
    if ((a * x) % m == 1) {
    return x;
    }
    }
    return -1; // Modular inverse doesn't exist
    }

    // Function to generate keys


    void generate_keypair(int *e, int *d, int *n) {
    int p = 61; // First prime number
    int q = 53; // Second prime number

    *n = p * q; // n = p * q
    int phi = (p - 1) * (q - 1); // Euler's totient

    // Choose e
    *e = 3; // Commonly used value for e
    while (gcd(*e, phi) != 1) {
    (*e) += 2; // Increment to find a suitable e
    }

    // Compute d
    *d = mod_inverse(*e, phi);
    }

    // Function to encrypt plaintext


    int encrypt(int plaintext, int e, int n) {
    return (int)pow(plaintext, e) % n;
    }

    // Function to decrypt ciphertext


    int decrypt(int ciphertext, int d, int n) {
    return (int)pow(ciphertext, d) % n;
    }

    // Main function
    int main() {
    int e, d, n;
    generate_keypair(&e, &d, &n);

    printf("Public Key: (e: %d, n: %d)\n", e, n);


    printf("Private Key: (d: %d, n: %d)\n", d, n);

    int message = 42; // Example message (should be less than n)


    printf("Original Message: %d\n", message);

    // Encrypt the message


    int encrypted_msg = encrypt(message, e, n);
    printf("Encrypted Message: %d\n", encrypted_msg);

    // Decrypt the message


    int decrypted_msg = decrypt(encrypted_msg, d, n);
    printf("Decrypted Message: %d\n", decrypted_msg);

    return 0;
    }

    Output:
    Public Key: (e: 7, n: 3233)
    Private Key: (d: 1783, n: 3233)
    Original Message: 42
    Encrypted Message: -2194
    Decrypted Message: -2194
    Practical-8

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

    // Function to perform modular exponentiation


    int power_mod(int base, int exponent, int modulus) {
    int result = 1;
    base = base % modulus;
    while (exponent > 0) {
    if (exponent % 2 == 1) {
    result = (result * base) % modulus;
    }
    exponent = exponent >> 1; // Divide exponent by 2
    base = (base * base) % modulus; // Square the base
    }
    return result;
    }

    // Function to generate a random private key


    int generate_private_key(int prime) {
    return rand() % (prime - 2) + 1; // Random number between 1 and prime-2
    }

    // Main function for Diffie-Hellman Key Exchange


    int main() {
    srand(time(NULL)); // Seed random number generator

    // Example prime number and base


    int prime = 23; // A prime number
    int base = 5; // A primitive root modulo prime

    // Generate private keys


    int alice_private = generate_private_key(prime);
    int bob_private = generate_private_key(prime);
    // Calculate public keys
    int alice_public = power_mod(base, alice_private, prime);
    int bob_public = power_mod(base, bob_private, prime);

    // Calculate shared secrets


    int alice_shared_secret = power_mod(bob_public, alice_private, prime);
    int bob_shared_secret = power_mod(alice_public, bob_private, prime);

    // Display keys
    printf("Alice's Private Key: %d\n", alice_private);
    printf("Bob's Private Key: %d\n", bob_private);
    printf("Alice's Public Key: %d\n", alice_public);
    printf("Bob's Public Key: %d\n", bob_public);
    printf("Shared Secret (Alice): %d\n", alice_shared_secret);
    printf("Shared Secret (Bob): %d\n", bob_shared_secret);

    return 0;
    }

    Output:
    Alice's Private Key: 4
    Bob's Private Key: 8
    Alice's Public Key: 4
    Bob's Public Key: 16
    Shared Secret (Alice): 9
    Shared Secret (Bob): 9

    You might also like