From 3aff0baacf8cffc5abc3e322ab194d30e3c12d6f Mon Sep 17 00:00:00 2001 From: klein panic Date: Sat, 1 Feb 2025 16:14:45 -0500 Subject: [PATCH] testing --- Advanced-Encryption-Standard/README.md | 14 ++ Advanced-Encryption-Standard/build/Makefile | 28 +++ Advanced-Encryption-Standard/build/aes | Bin 0 -> 16424 bytes Advanced-Encryption-Standard/include/aes.h | 9 + Advanced-Encryption-Standard/obj/aes.o | Bin 0 -> 4848 bytes Advanced-Encryption-Standard/obj/main.o | Bin 0 -> 2224 bytes Advanced-Encryption-Standard/src/aes.c | 210 ++++++++++++++++++ Advanced-Encryption-Standard/src/main.c | 31 +++ Base64_Encoding/README.md | 21 ++ Base64_Encoding/build/Makefile | 28 +++ Base64_Encoding/build/base64_encoder | Bin 0 -> 16496 bytes Base64_Encoding/include/base64_encoder.h | 9 + Base64_Encoding/obj/base64_encoder.o | Bin 0 -> 3576 bytes Base64_Encoding/obj/main.o | Bin 0 -> 2496 bytes Base64_Encoding/src/base64_encoder.c | 96 ++++++++ Base64_Encoding/src/main.c | 39 ++++ Caesar_Cipher/README.md | 22 ++ Caesar_Cipher/build/Makefile | 27 +++ Caesar_Cipher/build/caesar_cipher | Bin 0 -> 16264 bytes Caesar_Cipher/include/caesar_cipher.h | 8 + Caesar_Cipher/obj/caesar_cipher.o | Bin 0 -> 1912 bytes Caesar_Cipher/obj/main.o | Bin 0 -> 2104 bytes Caesar_Cipher/src/caesar_cipher.c | 21 ++ Caesar_Cipher/src/main.c | 24 ++ Data-Encryption-Standard/README.md | 16 ++ Data-Encryption-Standard/build/Makefile | 28 +++ Data-Encryption-Standard/build/des | Bin 0 -> 16312 bytes Data-Encryption-Standard/include/des.h | 7 + Data-Encryption-Standard/obj/des.o | Bin 0 -> 2128 bytes Data-Encryption-Standard/obj/main.o | Bin 0 -> 2080 bytes Data-Encryption-Standard/src/des.c | 76 +++++++ Data-Encryption-Standard/src/main.c | 25 +++ Diffie-Hellman-Key-Exchange/README.md | 14 ++ Diffie-Hellman-Key-Exchange/build/Makefile | 27 +++ .../build/diffie_hellman | Bin 0 -> 16264 bytes .../include/diffie_hellman.h | 7 + .../obj/diffie_hellman.o | Bin 0 -> 1368 bytes Diffie-Hellman-Key-Exchange/obj/main.o | Bin 0 -> 2728 bytes .../src/diffie_hellman.c | 21 ++ Diffie-Hellman-Key-Exchange/src/main.c | 42 ++++ Elliptic-Curve-Cryptography/README.md | 78 +++++++ Elliptic-Curve-Cryptography/build/Makefile | 18 ++ Elliptic-Curve-Cryptography/build/ecc | Bin 0 -> 16304 bytes Elliptic-Curve-Cryptography/include/ecc.h | 35 +++ Elliptic-Curve-Cryptography/obj/ecc.o | Bin 0 -> 3696 bytes Elliptic-Curve-Cryptography/obj/main.o | Bin 0 -> 2320 bytes Elliptic-Curve-Cryptography/src/ecc.c | 96 ++++++++ Elliptic-Curve-Cryptography/src/ecc.c.bak | 92 ++++++++ Elliptic-Curve-Cryptography/src/main.c | 33 +++ README.md | 3 + Simple_Substitution/README.md | 15 ++ Simple_Substitution/build/Makefile | 28 +++ Simple_Substitution/build/substitution_cipher | Bin 0 -> 16432 bytes .../include/substitution_cipher.h | 7 + Simple_Substitution/obj/main.o | Bin 0 -> 2112 bytes Simple_Substitution/obj/substitution_cipher.o | Bin 0 -> 2224 bytes Simple_Substitution/src/main.c | 22 ++ Simple_Substitution/src/substitution_cipher.c | 36 +++ Vigenère_Cipher/README.md | 21 ++ Vigenère_Cipher/build/Makefile | 28 +++ Vigenère_Cipher/build/vigenere_cipher | Bin 0 -> 16360 bytes Vigenère_Cipher/include/vigenere_cipher.h | 7 + Vigenère_Cipher/obj/main.o | Bin 0 -> 2256 bytes Vigenère_Cipher/obj/vigenere_cipher.o | Bin 0 -> 2200 bytes Vigenère_Cipher/src/main.c | 26 +++ Vigenère_Cipher/src/vigenere_cipher.c | 28 +++ XOR_Encryption/README.md | 21 ++ XOR_Encryption/build/Makefile | 27 +++ XOR_Encryption/build/xor_cipher | Bin 0 -> 16416 bytes XOR_Encryption/include/xor_cipher.h | 6 + XOR_Encryption/obj/main.o | Bin 0 -> 3040 bytes XOR_Encryption/obj/xor_cipher.o | Bin 0 -> 1360 bytes XOR_Encryption/src/main.c | 54 +++++ XOR_Encryption/src/xor_cipher.c | 10 + rsa-algorithms/README.md | 3 + rsa-algorithms/build/Makefile | 28 +++ rsa-algorithms/build/rsa | Bin 0 -> 16320 bytes rsa-algorithms/include/rsa.h | 8 + rsa-algorithms/obj/main.o | Bin 0 -> 2392 bytes rsa-algorithms/obj/rsa.o | Bin 0 -> 2528 bytes rsa-algorithms/src/main.c | 33 +++ rsa-algorithms/src/rsa.c | 81 +++++++ 82 files changed, 1694 insertions(+) create mode 100644 Advanced-Encryption-Standard/README.md create mode 100644 Advanced-Encryption-Standard/build/Makefile create mode 100755 Advanced-Encryption-Standard/build/aes create mode 100644 Advanced-Encryption-Standard/include/aes.h create mode 100644 Advanced-Encryption-Standard/obj/aes.o create mode 100644 Advanced-Encryption-Standard/obj/main.o create mode 100644 Advanced-Encryption-Standard/src/aes.c create mode 100644 Advanced-Encryption-Standard/src/main.c create mode 100644 Base64_Encoding/README.md create mode 100644 Base64_Encoding/build/Makefile create mode 100755 Base64_Encoding/build/base64_encoder create mode 100644 Base64_Encoding/include/base64_encoder.h create mode 100644 Base64_Encoding/obj/base64_encoder.o create mode 100644 Base64_Encoding/obj/main.o create mode 100644 Base64_Encoding/src/base64_encoder.c create mode 100644 Base64_Encoding/src/main.c create mode 100644 Caesar_Cipher/README.md create mode 100644 Caesar_Cipher/build/Makefile create mode 100755 Caesar_Cipher/build/caesar_cipher create mode 100644 Caesar_Cipher/include/caesar_cipher.h create mode 100644 Caesar_Cipher/obj/caesar_cipher.o create mode 100644 Caesar_Cipher/obj/main.o create mode 100644 Caesar_Cipher/src/caesar_cipher.c create mode 100644 Caesar_Cipher/src/main.c create mode 100644 Data-Encryption-Standard/README.md create mode 100644 Data-Encryption-Standard/build/Makefile create mode 100755 Data-Encryption-Standard/build/des create mode 100644 Data-Encryption-Standard/include/des.h create mode 100644 Data-Encryption-Standard/obj/des.o create mode 100644 Data-Encryption-Standard/obj/main.o create mode 100644 Data-Encryption-Standard/src/des.c create mode 100644 Data-Encryption-Standard/src/main.c create mode 100644 Diffie-Hellman-Key-Exchange/README.md create mode 100644 Diffie-Hellman-Key-Exchange/build/Makefile create mode 100755 Diffie-Hellman-Key-Exchange/build/diffie_hellman create mode 100644 Diffie-Hellman-Key-Exchange/include/diffie_hellman.h create mode 100644 Diffie-Hellman-Key-Exchange/obj/diffie_hellman.o create mode 100644 Diffie-Hellman-Key-Exchange/obj/main.o create mode 100644 Diffie-Hellman-Key-Exchange/src/diffie_hellman.c create mode 100644 Diffie-Hellman-Key-Exchange/src/main.c create mode 100644 Elliptic-Curve-Cryptography/README.md create mode 100644 Elliptic-Curve-Cryptography/build/Makefile create mode 100755 Elliptic-Curve-Cryptography/build/ecc create mode 100644 Elliptic-Curve-Cryptography/include/ecc.h create mode 100644 Elliptic-Curve-Cryptography/obj/ecc.o create mode 100644 Elliptic-Curve-Cryptography/obj/main.o create mode 100644 Elliptic-Curve-Cryptography/src/ecc.c create mode 100644 Elliptic-Curve-Cryptography/src/ecc.c.bak create mode 100644 Elliptic-Curve-Cryptography/src/main.c create mode 100644 README.md create mode 100644 Simple_Substitution/README.md create mode 100644 Simple_Substitution/build/Makefile create mode 100755 Simple_Substitution/build/substitution_cipher create mode 100644 Simple_Substitution/include/substitution_cipher.h create mode 100644 Simple_Substitution/obj/main.o create mode 100644 Simple_Substitution/obj/substitution_cipher.o create mode 100644 Simple_Substitution/src/main.c create mode 100644 Simple_Substitution/src/substitution_cipher.c create mode 100644 Vigenère_Cipher/README.md create mode 100644 Vigenère_Cipher/build/Makefile create mode 100755 Vigenère_Cipher/build/vigenere_cipher create mode 100644 Vigenère_Cipher/include/vigenere_cipher.h create mode 100644 Vigenère_Cipher/obj/main.o create mode 100644 Vigenère_Cipher/obj/vigenere_cipher.o create mode 100644 Vigenère_Cipher/src/main.c create mode 100644 Vigenère_Cipher/src/vigenere_cipher.c create mode 100644 XOR_Encryption/README.md create mode 100644 XOR_Encryption/build/Makefile create mode 100755 XOR_Encryption/build/xor_cipher create mode 100644 XOR_Encryption/include/xor_cipher.h create mode 100644 XOR_Encryption/obj/main.o create mode 100644 XOR_Encryption/obj/xor_cipher.o create mode 100644 XOR_Encryption/src/main.c create mode 100644 XOR_Encryption/src/xor_cipher.c create mode 100644 rsa-algorithms/README.md create mode 100644 rsa-algorithms/build/Makefile create mode 100755 rsa-algorithms/build/rsa create mode 100644 rsa-algorithms/include/rsa.h create mode 100644 rsa-algorithms/obj/main.o create mode 100644 rsa-algorithms/obj/rsa.o create mode 100644 rsa-algorithms/src/main.c create mode 100644 rsa-algorithms/src/rsa.c diff --git a/Advanced-Encryption-Standard/README.md b/Advanced-Encryption-Standard/README.md new file mode 100644 index 0000000..5d514c5 --- /dev/null +++ b/Advanced-Encryption-Standard/README.md @@ -0,0 +1,14 @@ +# AES Encryption Algorithm + +## Description +This project implements a basic version of the AES-128 encryption algorithm, with simplified transformations for SubBytes, ShiftRows, MixColumns, and AddRoundKey. + +## How to Build +1. Navigate to the `build` directory. +2. Run `make` to compile the project. + +## How to Run +1. After building, run the `aes` executable using `./aes`. + +## How to Clean +- Run `make clean` to remove all compiled files. diff --git a/Advanced-Encryption-Standard/build/Makefile b/Advanced-Encryption-Standard/build/Makefile new file mode 100644 index 0000000..6c6464c --- /dev/null +++ b/Advanced-Encryption-Standard/build/Makefile @@ -0,0 +1,28 @@ +# Variables +CC = gcc +CFLAGS = -I../include -Wall -Wextra +OBJDIR = ../obj +SRCDIR = ../src +BINDIR = ../build + +# Source files +SOURCES = $(SRCDIR)/main.c $(SRCDIR)/aes.c +OBJECTS = $(OBJDIR)/main.o $(OBJDIR)/aes.o + +# Build target +TARGET = aes + +# Rules +all: $(BINDIR)/$(TARGET) + +$(BINDIR)/$(TARGET): $(OBJECTS) + $(CC) $(OBJECTS) -o $(BINDIR)/$(TARGET) + +$(OBJDIR)/%.o: $(SRCDIR)/%.c + $(CC) $(CFLAGS) -c $< -o $@ + +clean: + rm -f $(OBJDIR)/*.o $(BINDIR)/$(TARGET) + +.PHONY: all clean + diff --git a/Advanced-Encryption-Standard/build/aes b/Advanced-Encryption-Standard/build/aes new file mode 100755 index 0000000000000000000000000000000000000000..5857556d95f9ec68f9cddf7af10d36dd5440fffa GIT binary patch literal 16424 zcmb<-^>JfjWMqH=W(GS35HCRhBH{p{7&0uN3!)Oi&mw_3oPXfeXU|>L}WuWR{G{{XLArK9+55&fX13(U9U|@jJ3{Zc7 z^s$08K>09n7_G<+l4M|j(J*n4KCpcX5P1eP`U+T*fdNJ%>jOFEf-Xeg1zS`)02(e4 zP#UHW#0BYl0M+*Zst-;MS`J}pTBg$syH42DH>5Y#?g z@n8T7a0Uhj7!3_p2K}7OBr_BJoD|)h%)HVH-3kjcT{9EC;(R?Lu=OB!f$RXKDR;k6 z2Brpv10XS&eh^!PfdQP(LGtnoB&Iz~to)E;$f=RC{d!Y-x?es>4af|T9*`Q4!Jue> zItj#O0I}H_7{GZF;{QglI7ke{xR`n_7ewR2AhU(ANOCeTFkll8VqkzLab#^;IMnCi zP+yBfT$+J_0UGtl#xpP!l$IoCBo;Bm$LC}wCC3++Bo>v#=O$+6F~r9wS0u)#W#%R3 zWLBjz6clCVm83C%RDq(yjKST<)5$sBNYB^=&NR|9Wr+6-@r_SOElN$#EG|hc3h{N$ z$a7)~IG zgVGL6`~s3VD2>9zZyeqS^|qPFfec+iG$KHOnj6c4S~@R z7!85Z5Eu=C(GVC7fzc2c+#%r6{D#A$oAszZ1A|BFffANH@&cIOrO&{SHUXpngbm+%c3zD0 z=zQeS{NzJGh^yfN!;>Dpw&xfa82*de>oYKXNz>z(ZviOe0h9?7RXx;O zK)^JR_xQItFm|~92QfW*0~kRx|27BK4ki%Gqc?yRMDuTR;Dn2CLPdDtBE0
nFO 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 literal 0 HcmV?d00001 diff --git a/Advanced-Encryption-Standard/include/aes.h b/Advanced-Encryption-Standard/include/aes.h new file mode 100644 index 0000000..c958a8b --- /dev/null +++ b/Advanced-Encryption-Standard/include/aes.h @@ -0,0 +1,9 @@ +#ifndef AES_H +#define AES_H + +#include + +void aes_encrypt(uint8_t *message, uint8_t *key); +void aes_decrypt(uint8_t *message, uint8_t *key); + +#endif // AES_H diff --git a/Advanced-Encryption-Standard/obj/aes.o b/Advanced-Encryption-Standard/obj/aes.o new file mode 100644 index 0000000000000000000000000000000000000000..29a9e0e569659990624f030ec0f14c2d4f3aa29e GIT binary patch literal 4848 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 literal 0 HcmV?d00001 diff --git a/Advanced-Encryption-Standard/src/aes.c b/Advanced-Encryption-Standard/src/aes.c new file mode 100644 index 0000000..0513d77 --- /dev/null +++ b/Advanced-Encryption-Standard/src/aes.c @@ -0,0 +1,210 @@ +#include "aes.h" +#include +#include + +// Real AES S-box +static const uint8_t sbox[256] = { + 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, + 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, + 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, + 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, + 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, + 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, + 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, + 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, + 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, + 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, + 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, + 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, + 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, + 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, + 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, + 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 +}; + +// Real AES inverse S-box +static const uint8_t inv_sbox[256] = { + 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, + 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, + 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, + 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, + 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, + 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, + 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, + 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, + 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, + 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, + 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, + 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, + 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, + 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, + 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, + 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d +}; + +// Add round key step +static void add_round_key(uint8_t *state, uint8_t *round_key) { + for (int i = 0; i < 16; i++) { + state[i] ^= round_key[i]; + } +} + +// Substitute bytes using the S-box +static void sub_bytes(uint8_t *state) { + for (int i = 0; i < 16; i++) { + state[i] = sbox[state[i]]; + } +} + +// Inverse substitute bytes using the inverse S-box +static void inv_sub_bytes(uint8_t *state) { + for (int i = 0; i < 16; i++) { + state[i] = inv_sbox[state[i]]; + } +} + +// Shift rows step (left shift each row by its row number) +static void shift_rows(uint8_t *state) { + uint8_t temp; + + // Row 1 shift (1-byte left) + temp = state[1]; + state[1] = state[5]; + state[5] = state[9]; + state[9] = state[13]; + state[13] = temp; + + // Row 2 shift (2-byte left) + temp = state[2]; + state[2] = state[10]; + state[10] = temp; + temp = state[6]; + state[6] = state[14]; + state[14] = temp; + + // Row 3 shift (3-byte left) + temp = state[3]; + state[3] = state[15]; + state[15] = state[11]; + state[11] = state[7]; + state[7] = temp; +} + +// Inverse ShiftRows step (right shift each row by its row number) +static void inv_shift_rows(uint8_t *state) { + uint8_t temp; + + // Row 1 shift (1-byte right) + temp = state[13]; + state[13] = state[9]; + state[9] = state[5]; + state[5] = state[1]; + state[1] = temp; + + // Row 2 shift (2-byte right) + temp = state[2]; + state[2] = state[10]; + state[10] = temp; + temp = state[6]; + state[6] = state[14]; + state[14] = temp; + + // Row 3 shift (3-byte right) + temp = state[3]; + state[3] = state[7]; + state[7] = state[11]; + state[11] = state[15]; + state[15] = temp; +} + +// Galois field multiplication for MixColumns +static uint8_t gmul(uint8_t a, uint8_t b) { + uint8_t p = 0; + while (b) { + if (b & 1) p ^= a; + if (a & 0x80) a = (a << 1) ^ 0x1b; + else a <<= 1; + b >>= 1; + } + return p; +} + +// MixColumns step +static void mix_columns(uint8_t *state) { + for (int i = 0; i < 4; i++) { + uint8_t a = state[i * 4 + 0]; + uint8_t b = state[i * 4 + 1]; + uint8_t c = state[i * 4 + 2]; + uint8_t d = state[i * 4 + 3]; + + state[i * 4 + 0] = gmul(a, 0x02) ^ gmul(b, 0x03) ^ c ^ d; + state[i * 4 + 1] = a ^ gmul(b, 0x02) ^ gmul(c, 0x03) ^ d; + state[i * 4 + 2] = a ^ b ^ gmul(c, 0x02) ^ gmul(d, 0x03); + state[i * 4 + 3] = gmul(a, 0x03) ^ b ^ c ^ gmul(d, 0x02); + } +} + +// Inverse MixColumns step +static void inv_mix_columns(uint8_t *state) { + for (int i = 0; i < 4; i++) { + uint8_t a = state[i * 4 + 0]; + uint8_t b = state[i * 4 + 1]; + uint8_t c = state[i * 4 + 2]; + uint8_t d = state[i * 4 + 3]; + + state[i * 4 + 0] = gmul(a, 0x0e) ^ gmul(b, 0x0b) ^ gmul(c, 0x0d) ^ gmul(d, 0x09); + state[i * 4 + 1] = gmul(a, 0x09) ^ gmul(b, 0x0e) ^ gmul(c, 0x0b) ^ gmul(d, 0x0d); + state[i * 4 + 2] = gmul(a, 0x0d) ^ gmul(b, 0x09) ^ gmul(c, 0x0e) ^ gmul(d, 0x0b); + state[i * 4 + 3] = gmul(a, 0x0b) ^ gmul(b, 0x0d) ^ gmul(c, 0x09) ^ gmul(d, 0x0e); + } +} + +// Perform AES encryption +void aes_encrypt(uint8_t *message, uint8_t *key) { + uint8_t state[16]; + memcpy(state, message, 16); + + // Perform the initial round key addition + add_round_key(state, key); + + // Perform 9 rounds of AES transformations + for (int round = 0; round < 9; round++) { + sub_bytes(state); + shift_rows(state); + mix_columns(state); + add_round_key(state, key); // Using the same key as a placeholder + } + + // Final round (no MixColumns) + sub_bytes(state); + shift_rows(state); + add_round_key(state, key); + + // Copy the result back into the message + memcpy(message, state, 16); +} + +// Perform AES decryption (inverse operations) +void aes_decrypt(uint8_t *message, uint8_t *key) { + uint8_t state[16]; + memcpy(state, message, 16); + + // Initial round key addition (same as the last round of encryption) + add_round_key(state, key); + + // Perform 9 rounds of inverse AES transformations + for (int round = 0; round < 9; round++) { + inv_shift_rows(state); + inv_sub_bytes(state); + add_round_key(state, key); // Using the same key as a placeholder + inv_mix_columns(state); + } + + // Final round (no InvMixColumns) + inv_shift_rows(state); + inv_sub_bytes(state); + add_round_key(state, key); + + // Copy the result back into the message + memcpy(message, state, 16); +} diff --git a/Advanced-Encryption-Standard/src/main.c b/Advanced-Encryption-Standard/src/main.c new file mode 100644 index 0000000..353d296 --- /dev/null +++ b/Advanced-Encryption-Standard/src/main.c @@ -0,0 +1,31 @@ +#include "aes.h" +#include +#include + +int main() { + // Example 128-bit key and plaintext (16 bytes each) + uint8_t message[16] = {0x32, 0x43, 0xf6, 0xa8, 0x88, 0x5a, 0x30, 0x8d, + 0x31, 0x31, 0x98, 0xa2, 0xe0, 0x37, 0x07, 0x34}; + uint8_t key[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, + 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c}; + + printf("Original message: "); + for (int i = 0; i < 16; i++) printf("%02x ", message[i]); + printf("\n"); + + // Encrypt the message + aes_encrypt(message, key); + + printf("Encrypted message: "); + for (int i = 0; i < 16; i++) printf("%02x ", message[i]); + printf("\n"); + + // Decrypt the message + aes_decrypt(message, key); + + printf("Decrypted message: "); + for (int i = 0; i < 16; i++) printf("%02x ", message[i]); + printf("\n"); + + return 0; +} diff --git a/Base64_Encoding/README.md b/Base64_Encoding/README.md new file mode 100644 index 0000000..9c994b9 --- /dev/null +++ b/Base64_Encoding/README.md @@ -0,0 +1,21 @@ +# Base64 Encoder + +## Description +This project implements a Base64 encoder and decoder for educational purposes. Base64 encoding converts binary data to text, using a set of 64 printable characters. + +## Directory Structure +- `include/`: Contains the header files. +- `src/`: Contains the source code files (`main.c` and `base64_encoder.c`). +- `obj/`: Contains the compiled object files. +- `build/`: Contains the Makefile and the compiled binary. + +## How to Build +1. Navigate to the `build` directory. +2. Run `make` to compile the project. + +## How to Run +1. After building, you will find an executable named `base64_encoder` in the `build` directory. +2. Run it using `./base64_encoder`. + +## How to Clean +- Run `make clean` in the `build` directory to remove all compiled files. diff --git a/Base64_Encoding/build/Makefile b/Base64_Encoding/build/Makefile new file mode 100644 index 0000000..7d349aa --- /dev/null +++ b/Base64_Encoding/build/Makefile @@ -0,0 +1,28 @@ +# Variables +CC = gcc +CFLAGS = -I../include -Wall -Wextra +OBJDIR = ../obj +SRCDIR = ../src +BINDIR = ../build + +# Source files +SOURCES = $(SRCDIR)/main.c $(SRCDIR)/base64_encoder.c +OBJECTS = $(OBJDIR)/main.o $(OBJDIR)/base64_encoder.o + +# Build target +TARGET = base64_encoder + +# Rules +all: $(BINDIR)/$(TARGET) + +$(BINDIR)/$(TARGET): $(OBJECTS) + $(CC) $(OBJECTS) -o $(BINDIR)/$(TARGET) + +$(OBJDIR)/%.o: $(SRCDIR)/%.c + $(CC) $(CFLAGS) -c $< -o $@ + +clean: + rm -f $(OBJDIR)/*.o $(BINDIR)/$(TARGET) + +.PHONY: all clean + diff --git a/Base64_Encoding/build/base64_encoder b/Base64_Encoding/build/base64_encoder new file mode 100755 index 0000000000000000000000000000000000000000..bb3604027e2e7047b4b7819709a1bcd77150f37b GIT binary patch literal 16496 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 // Include this to define size_t + +char *base64_encode(const unsigned char *data, size_t input_length, size_t *output_length); +unsigned char *base64_decode(const char *data, size_t input_length, size_t *output_length); + +#endif // BASE64_ENCODER_H diff --git a/Base64_Encoding/obj/base64_encoder.o b/Base64_Encoding/obj/base64_encoder.o new file mode 100644 index 0000000000000000000000000000000000000000..e2519d3c36d9aa0ea954026641403019d57b6956 GIT binary patch literal 3576 zcmb<-^>JfjWMqH=Mg}_u1P><4z_5c0!FB*M9T<2Sco;%GI-hp_=y3hhQ2WQBj=!Py zPgFf8|3240%`Y5Zdp6YmNdOC0!35o3n>5t^(FY4!LIn@7yq0gM{i9vVzQc}zf#J0f zNJT084to%Xb;tkz|NqAx23h3M{3gJov-X5XXXyct&d?nm-L3~bnh!8}>{`7F0zAGy z^60$aaq)#muShG%nI7G)J3KlCz*IMbNAm$jkIv&Sz%re#4?LP{A25`1?Evv#vNJI- zcpP{A0pfTZcl`jOU-~gJFnDyk{_wDNJy0wSX7vUzdUS^V@aPUb;lX%;e;Wh;wgazO z!De*2-T^BiQt=H^6kq9fy>sw^KT+dZF9(!oe3p%@6E54|;UF ze(->}?t@2n=mQVNL!Bo*dRajp;oru>*uex=%tMM|HsTc%sS@UA{-!1W{{Qzl?h1~L z*K)8Z(sq5}(HrpJqucd?2jhif47MK4t}hrpx_u8IMRVr~P)uKZ1&VCO10IYQJTwn_ zbe`J5%)r3lp?Sfh^B`fx9+sgmiaH_If)WVCI#6ssIEgd4H9uhXXgyFO2@O_QVgkqh z%Nd{)1WJ=`CA%4*641m7QuoiJ+m(>I9Uk2b zFgJK~y1wveu6@B!irsa;KuH-reV+vhf>JUlje}FOjV*u6aj>ZC4`^yaPV4&)bRK`f z_UHfqPS+>ksDvaq3?+|$gOoe~D*%8lmQ zC;v-?nrk2YFX3sfz4O0>t-1Eb|58=7xb*0DeE|zoNW30kU|{HWeRA-D5GeOOIQW2v z^AI>UvVn5pjZW7qut>CY{ZK65?Rw?l3jvJ$_`-wnLg%RtP*MX&8$vAyQEDa7@;Au5 z?$9f!1`2}%)!Ov{f0OFJ|NmdJOnA*W0pz2The5>v26l9Ec5!uc_we-c_VM-e4+snj z4hanlkBE#)OiE5kO-s+n%*xKm&C4$+EGjN3Ei136tTHe(GBz7qTrNRoN8vGkercNl$czSTBMMYT9TSv z0@mQ}>};i=;gXt^nV6?wXryPPXP|3nq6uY!ZDn8(fzpgsK@5x)0*ul;>>Lvq85m?3 zAQ&W_2_hW%1lpLKdD)m!c-T20ayB4w1_p+FCI$uum^^b96G#C_e+*RqGK%~;usl=> zg96pHEDRt2V@NPCFfe1Si9zDvA{|AG5Ca1PBLhO*5h^Rsz`($SWDeMG3=9m03=9lH z42%pgKG;tT3=E(;R{*LPnR0`wzX9?a0|Nutj|>b9Aq)%**wjbj5NAjN$6$PFUUGg) zYLQ+tOaK(6#mJoavc#OyRG0`vJwq-yrN9JJQbC3=6qJ?}Go%%zrZO-vY=b(Qg@J*A zoq>Vj52*F<|Ns9bpnwL41t|Ow;ump<|HC1!0rfwK0#!CJ^M8W`kj!_1x`P>{h=G9t zDh{HM?Y#{WfSLnp(!t!X z0M!Sw7lff)21r{El!hP}mR=H|3P5T>7?v&=^olEUOA?b9^omQ0Aan+dRg{{Os8^C& zQNo~?l30?+pqEr!%%E4458))|=jNv7l`!b#<(H)Dx%-9c7MCO@XEW%5wWVgnrxhjU zf}$8|Gi4OWzn~~)Lo){E-_?k$1Xcl33uZtGX=oV2)I)_CE^t6t7EleKFa|N9!VD4+ zX$CcLeubn(s1TTXjb<-c5ULi&2GKeU3=AMMp~(Uy1jfYb2jzc|yFhUV)(9h@0dfk) zhti<%f-=FBCDcs@U><@v1=WwP9%L6t6^wR*>IaD-<5y7q$YLNiOdp61!r@T;=wT##N61_{C959A(nyFv09pv(-48;}A91_o{h x1_qFm(Dj4zBzoL|^cO%C#(_9U7-}3`L=ap*z`1Zn0LZ}%3=D~I5eNfaKLD!&a?$_* literal 0 HcmV?d00001 diff --git a/Base64_Encoding/obj/main.o b/Base64_Encoding/obj/main.o new file mode 100644 index 0000000000000000000000000000000000000000..c8c1e1bb4acc74336b9f424e81062433a0e6365e GIT binary patch literal 2496 zcmb<-^>JfjWMqH=Mg}_u1P><4z|g>kU^{@B4h*~uJPe^8oliX)-zYFLFnIK`f+RdT zkM97{FF=Gxw6uwLch2B@wOw+p+`XnU^aV7#KXdU4M9V9z)0@yRsKz?$ie$ zF8cR0*LMY&OJ1h;P95ymt2JZUq_9dC;TV^@B&}q0Vy%J;?TfoC47Z zQ3zp!Rh&HRnpcuqq>!kPn_66)n4YRolCO}Omz;?t~23`gR1_2b65Dv&6*uMfxBgHRfz9+cW(?zx8~&Vyvm2dFsA z9A7B^2b2bxgKRGgDB(lh14^SX^HreYFmtk@`VFDtAaju2V~Zq?Y>p=maZox283{5U zgh6aD)+?^eElEsb&?_z}g3uW-R#9qBqFzaAMG1pmN@7VOgI-c`F@s)FK7^B;pPQSS zSHhr|mtT^q=k6D(TU?TuoXwyI)|Q$PpH`HZ3r<^LdnhD8?gx1dl-7`qg49tA46u9; zlLM)Ru|YH_9fQIUrXC~)!U`Zk1_p))Pz|6o1!98IB1j&VPSqF~z@-c*?SjN%cnU}{ zjDtj@3+pg2Fo4V?SHB_Dew4UlU|@jR--cv2h>32$B~-rwND>K4K@9|jFOo3WuOL3m z98ft0V}rzD*b1s2#)r}9YQv%SqbqlS3c&IoOg|{BU~CW_1kE$(@y7s75U_Xx#UDs7 z2!r&j+XS_Kk@;|i!?07wA?0|O|pf|3Nfeoz^N9(N!^PCx}iK^!CuH4ZK!2rXCP R0#Jqo)cuK2K8!-w4*>sNjx7KH literal 0 HcmV?d00001 diff --git a/Base64_Encoding/src/base64_encoder.c b/Base64_Encoding/src/base64_encoder.c new file mode 100644 index 0000000..3612978 --- /dev/null +++ b/Base64_Encoding/src/base64_encoder.c @@ -0,0 +1,96 @@ +#include "base64_encoder.h" +#include +#include +#include +#include + +static const char base64_chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "0123456789+/"; + +static int base64_char_value(char c) { + if (c >= 'A' && c <= 'Z') return c - 'A'; + if (c >= 'a' && c <= 'z') return c - 'a' + 26; + if (c >= '0' && c <= '9') return c - '0' + 52; + if (c == '+') return 62; + if (c == '/') return 63; + return -1; // Should never happen for valid Base64 strings +} + +char *base64_encode(const unsigned char *data, size_t input_length, size_t *output_length) { + *output_length = 4 * ((input_length + 2) / 3); + char *encoded_data = (char *)malloc(*output_length + 1); + if (encoded_data == NULL) return NULL; + + for (size_t i = 0, j = 0; i < input_length;) { + uint32_t octet_a = i < input_length ? (unsigned char)data[i++] : 0; + uint32_t octet_b = i < input_length ? (unsigned char)data[i++] : 0; + uint32_t octet_c = i < input_length ? (unsigned char)data[i++] : 0; + + uint32_t triple = (octet_a << 16) | (octet_b << 8) | octet_c; + + encoded_data[j++] = base64_chars[(triple >> 18) & 0x3F]; + encoded_data[j++] = base64_chars[(triple >> 12) & 0x3F]; + encoded_data[j++] = base64_chars[(triple >> 6) & 0x3F]; + encoded_data[j++] = base64_chars[triple & 0x3F]; + } + + for (size_t i = 0; i < ((3 - (input_length % 3)) % 3); i++) { + encoded_data[*output_length - 1 - i] = '='; + } + + encoded_data[*output_length] = '\0'; + return encoded_data; +} + +unsigned char *base64_decode(const char *data, size_t input_length, size_t *output_length) { + if (input_length % 4 != 0) { + printf("Error: Input length is not a multiple of 4.\n"); + return NULL; + } + + // Calculate output length, ignoring padding characters '=' + *output_length = (input_length / 4) * 3; + if (data[input_length - 1] == '=') (*output_length)--; + if (data[input_length - 2] == '=') (*output_length)--; + + unsigned char *decoded_data = (unsigned char *)malloc(*output_length); + if (decoded_data == NULL) { + printf("Error: Memory allocation failed.\n"); + return NULL; + } + + size_t i = 0, j = 0; + while (i < input_length) { + if (data[i] == '=') { + break; // Stop if we hit padding + } + + // Read four Base64 characters and map them to their 6-bit values + int sextet_a = base64_char_value(data[i++]); + int sextet_b = base64_char_value(data[i++]); + int sextet_c = (i < input_length && data[i] != '=') ? base64_char_value(data[i++]) : 0; + int sextet_d = (i < input_length && data[i] != '=') ? base64_char_value(data[i++]) : 0; + + if (sextet_a == -1 || sextet_b == -1 || sextet_c == -1 || sextet_d == -1) { + printf("Error: Invalid Base64 character detected.\n"); + free(decoded_data); + return NULL; + } + + // Combine the four 6-bit sextets into three bytes + uint32_t triple = (sextet_a << 18) | (sextet_b << 12) | (sextet_c << 6) | sextet_d; + + if (j < *output_length) decoded_data[j++] = (triple >> 16) & 0xFF; + if (j < *output_length) decoded_data[j++] = (triple >> 8) & 0xFF; + if (j < *output_length) decoded_data[j++] = triple & 0xFF; + + // Break once we have decoded the expected number of bytes + if (j >= *output_length) { + break; + } + } + + return decoded_data; +} + diff --git a/Base64_Encoding/src/main.c b/Base64_Encoding/src/main.c new file mode 100644 index 0000000..0e56bb8 --- /dev/null +++ b/Base64_Encoding/src/main.c @@ -0,0 +1,39 @@ +#include "base64_encoder.h" +#include +#include +#include // Include this for memory management functions like free + +int main() { + char message[256]; + size_t output_length; + + printf("Enter a message to encode: "); + fgets(message, sizeof(message), stdin); + message[strcspn(message, "\n")] = '\0'; // Remove newline character + + // Encode the message + char *encoded = base64_encode((unsigned char *)message, strlen(message), &output_length); + if (encoded == NULL) { + printf("Failed to encode the message.\n"); + return 1; + } + + printf("Encoded message: %s\n", encoded); + + // Decode the message + size_t decoded_length; + unsigned char *decoded = base64_decode(encoded, output_length, &decoded_length); + if (decoded == NULL) { + printf("Failed to decode the message.\n"); + free(encoded); + return 1; + } + + printf("Decoded message: %.*s\n", (int)decoded_length, decoded); + + // Clean up + free(encoded); + free(decoded); + + return 0; +} diff --git a/Caesar_Cipher/README.md b/Caesar_Cipher/README.md new file mode 100644 index 0000000..f1bb603 --- /dev/null +++ b/Caesar_Cipher/README.md @@ -0,0 +1,22 @@ +# Caesar Cipher + +## Description +This project implements a simple Caesar cipher to demonstrate basic encryption and decryption using a fixed shift value. + +## Directory Structure +- `include/`: Contains the header files. +- `src/`: Contains the source code files (`main.c` and `caesar_cipher.c`). +- `obj/`: Contains the compiled object files. +- `build/`: Contains the Makefile and the compiled binary. + +## How to Build +1. Navigate to the `build` directory. +2. Run `make` to compile the project. + +## How to Run +1. After building, you will find an executable named `caesar_cipher` in the `build` directory. +2. Run it using `./caesar_cipher`. + +## How to Clean +- Run `make clean` in the `build` directory to remove all compiled files. + diff --git a/Caesar_Cipher/build/Makefile b/Caesar_Cipher/build/Makefile new file mode 100644 index 0000000..93c8aa2 --- /dev/null +++ b/Caesar_Cipher/build/Makefile @@ -0,0 +1,27 @@ +# Variables +CC = gcc +CFLAGS = -I../include -Wall -Wextra +OBJDIR = ../obj +SRCDIR = ../src +BINDIR = ../build + +# Source files +SOURCES = $(SRCDIR)/main.c $(SRCDIR)/caesar_cipher.c +OBJECTS = $(OBJDIR)/main.o $(OBJDIR)/caesar_cipher.o + +# Build target +TARGET = caesar_cipher + +# Rules +all: $(BINDIR)/$(TARGET) + +$(BINDIR)/$(TARGET): $(OBJECTS) + $(CC) $(OBJECTS) -o $(BINDIR)/$(TARGET) + +$(OBJDIR)/%.o: $(SRCDIR)/%.c + $(CC) $(CFLAGS) -c $< -o $@ + +clean: + rm -f $(OBJDIR)/*.o $(BINDIR)/$(TARGET) + +.PHONY: all clean diff --git a/Caesar_Cipher/build/caesar_cipher b/Caesar_Cipher/build/caesar_cipher new file mode 100755 index 0000000000000000000000000000000000000000..5cecd6fbb20c1446d6757cc96bb374186a4da3c5 GIT binary patch literal 16264 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 literal 0 HcmV?d00001 diff --git a/Caesar_Cipher/include/caesar_cipher.h b/Caesar_Cipher/include/caesar_cipher.h new file mode 100644 index 0000000..352d686 --- /dev/null +++ b/Caesar_Cipher/include/caesar_cipher.h @@ -0,0 +1,8 @@ +#ifndef CAESAR_CIPHER_H +#define CAESAR_CIPHER_H + +void encrypt(char *plaintext, int shift); +void decrypt(char *ciphertext, int shift); + +#endif // CAESAR_CIPHER_H + diff --git a/Caesar_Cipher/obj/caesar_cipher.o b/Caesar_Cipher/obj/caesar_cipher.o new file mode 100644 index 0000000000000000000000000000000000000000..abbc4ecb8374727feba6a32d65c98d02d51532fb GIT binary patch literal 1912 zcmb<-^>JfjWMqH=Mg}_u1P><4z)-=0U^{@B4h%dD+zg=}oliZQ-za!=*1qU0eRACO z4@mOmIR*xX7a*2LH$!*mACKfy9^IiYJQz>$Zxiz1-*?G_@sbDQ1^(>}{M!$xGO#c( zv>xDZnM#r-CXl8Q_8o}~3=FSXcQ`UIFm$;7?som-k$l0U+w}#={A~>U`!4YBbN#J( zsN3}k;{}jZ<|Y3(NBlevzEU{&i@EdQ!JqP)r?O8;X`bjj#J|n;cP|eUiW!}!Is}?s z|1hEm@^52kIl$j4_5c6>2@_5p#t{e?N%9Xg5N431iNrwYyrAv+r1^jpmBT?C8V(HZ z&dyc}8ZN0xnTdG{hDLfudIq|NCYn$tC_RXP2nGfQ#;PC&#tH#OX&!ct35*O3G7Jz5 zl4b=ZKu11-HYR6YHf9D!9(E3}ybVZ_fq{VoMV=Wf50%28KuTE{KK{p$U|?Wi#*)$n z85kIZki@}mVPIg8WME(rz+#9xR6R@`*li$n$%(1OiAC|rnFSfCMS95$sd>pol?5dX z@$tzel?AEsN%1-P$qXr}5K*xIK-xgr421vuhk!tkAOiy^i-0jqToL3kEaG7}#1)|C zFflMNfH0KH0LjY`F_1XS9}IfMmANH}Nep_$B}EWA1I8*!%}LZNNv$Yh&`U`yNo3GV zDlTTwOU}>DP0cG|(96p&N!4@r3)L+yNleaW&;u(^&4^DcO3Y1#*-I%6@(;+XY-k3- z{KE_K43Zp3EfSYO8X9&m^)R^(W(X?*LNRcH(kdv;LHQC;S`8`=RSp$pVDLq=7bbyj zzYf$)a`hWR?Kgl~0HtB}gTe?*R)K`!_ykmN0#t+xoX;5;VD`iGgUp3m1yu>5 pBA|l$5H6eq*$3w^Fff4138+$JVFn3M=4D`Dh(r-(Kq^rn5&*3PN#y_l literal 0 HcmV?d00001 diff --git a/Caesar_Cipher/obj/main.o b/Caesar_Cipher/obj/main.o new file mode 100644 index 0000000000000000000000000000000000000000..41ef7f6b7b6a4745dd37093a75f5438f0c88a849 GIT binary patch literal 2104 zcmb<-^>JfjWMqH=Mg}_u1P><4!0>|w!FB*M9T<2Sco;%GI-hzpz7b$#VDRW=1xa{x z9^V0?Uw{aYZc#AR+sg3&|Nng;qdhv0L!_`N?`{3_@Be>~&STgN>z)dhgqYQN4Pg-2 zaB6A-d*I|@*SwO{B85bS+|=UY#Pn2!l6-~KyyT+Ff)XnQ28d*FMrK-xLSk-yXIwkj3NWFLI_Dc*bNK}47>~s3<4-BAsmoDu!&3IP_KYP zTpx$HISz4#+{Da0y<{-OP*9YaSCYn1T#}NR$B>quT2jmqAD>yApKNIvU!0tnm&O2% zW`-0^I{_*VGsgnTp9`fy<{;a< z1xcI>$(*B5ahN&&Q2r$-jcyJoUO`eI^&kvlgRx$5Wo}7g5`$iGNfCt3fU$~Fa}xDR zQY%Ur^imQ_5*hT8ii;Wait-_x@ znEoudi4X?5{gzPu1`ugD*$!0*3SYP&R4s@Pm1b~45(A0D@N$>}m;jVU7Y>K&M|b}U zs6tpifNBSa6^sp{gBTbXu*F{mNRWYn0Txf7_ydJA2!r&i}e+YOR`0FnU34V31F q+Jmkil!wvd4y6AD)KGg62MI%sgNq1aNjo6P2~hVZf;dPRT|WTpjUNF3 literal 0 HcmV?d00001 diff --git a/Caesar_Cipher/src/caesar_cipher.c b/Caesar_Cipher/src/caesar_cipher.c new file mode 100644 index 0000000..5dc4667 --- /dev/null +++ b/Caesar_Cipher/src/caesar_cipher.c @@ -0,0 +1,21 @@ +#include "caesar_cipher.h" +#include +#include + +void encrypt(char *plaintext, int shift) { + for (int i = 0; plaintext[i] != '\0'; i++) { + if (isalpha(plaintext[i])) { + char base = islower(plaintext[i]) ? 'a' : 'A'; + plaintext[i] = (plaintext[i] - base + shift) % 26 + base; + } + } +} + +void decrypt(char *ciphertext, int shift) { + for (int i = 0; ciphertext[i] != '\0'; i++) { + if (isalpha(ciphertext[i])) { + char base = islower(ciphertext[i]) ? 'a' : 'A'; + ciphertext[i] = (ciphertext[i] - base - shift + 26) % 26 + base; + } + } +} diff --git a/Caesar_Cipher/src/main.c b/Caesar_Cipher/src/main.c new file mode 100644 index 0000000..2554f67 --- /dev/null +++ b/Caesar_Cipher/src/main.c @@ -0,0 +1,24 @@ +#include "caesar_cipher.h" +#include + +int main() { + char message[256]; + int shift; + + printf("Enter a message to encrypt: "); + fgets(message, sizeof(message), stdin); + + printf("Enter shift amount (1-25): "); + scanf("%d", &shift); + + // Encrypt the message + encrypt(message, shift); + printf("Encrypted message: %s\n", message); + + // Decrypt the message + decrypt(message, shift); + printf("Decrypted message: %s\n", message); + + return 0; +} + diff --git a/Data-Encryption-Standard/README.md b/Data-Encryption-Standard/README.md new file mode 100644 index 0000000..0360aa4 --- /dev/null +++ b/Data-Encryption-Standard/README.md @@ -0,0 +1,16 @@ +# DES Encryption Algorithm + +## Description +This project implements a simplified version of the DES encryption algorithm, with encryption and decryption using a symmetric key. + +## How to Build +1. Navigate to the `build` directory. +2. Run `make` to compile the project. + +## How to Run +1. After building, run the `des` executable using `./des`. +2. You will be prompted to enter a message and a key, both as integers (64-bit). + +## How to Clean +- Run `make clean` to remove all compiled files. + diff --git a/Data-Encryption-Standard/build/Makefile b/Data-Encryption-Standard/build/Makefile new file mode 100644 index 0000000..431f568 --- /dev/null +++ b/Data-Encryption-Standard/build/Makefile @@ -0,0 +1,28 @@ +# Variables +CC = gcc +CFLAGS = -I../include -Wall -Wextra +OBJDIR = ../obj +SRCDIR = ../src +BINDIR = ../build + +# Source files +SOURCES = $(SRCDIR)/main.c $(SRCDIR)/des.c +OBJECTS = $(OBJDIR)/main.o $(OBJDIR)/des.o + +# Build target +TARGET = des + +# Rules +all: $(BINDIR)/$(TARGET) + +$(BINDIR)/$(TARGET): $(OBJECTS) + $(CC) $(OBJECTS) -o $(BINDIR)/$(TARGET) + +$(OBJDIR)/%.o: $(SRCDIR)/%.c + $(CC) $(CFLAGS) -c $< -o $@ + +clean: + rm -f $(OBJDIR)/*.o $(BINDIR)/$(TARGET) + +.PHONY: all clean + diff --git a/Data-Encryption-Standard/build/des b/Data-Encryption-Standard/build/des new file mode 100755 index 0000000000000000000000000000000000000000..916c4a99e899c7c7fc55fc1bd240cb99ad793949 GIT binary patch literal 16312 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 literal 0 HcmV?d00001 diff --git a/Data-Encryption-Standard/obj/main.o b/Data-Encryption-Standard/obj/main.o new file mode 100644 index 0000000000000000000000000000000000000000..f7f990fad540be24eb9b6e91c10f7f975c51e5f3 GIT binary patch literal 2080 zcmb<-^>JfjWMqH=Mg}_u1P><4!0>y`3?Khv zlV!%5G8h<`8NiW=q6K7y5R!VZ8yFZEco`TN1W;5$I3Ryu6IaHeULS`zLvCVbo?bGT zVkjue%qvM_h>y=K&QG?qj4w`3%u8cPNiB|t#wnPc0ttPHJGdbf0}}(tUknU?{zHHS zR2-BIK)!{Et3kzK>Ot-T2^oV31_lO@dNu}xIaW|{n0gZ^-yKSW)FYc83KfT`hnb%Q z6$hzDHop`}oE^#DW~eyKoCqj?0+a@sgKY0&Bymt&!u-1tDh@NJ5X#>NrP0k%fQp0E zgD{lKz@S%LnOl;W#GqGPQUswhV639loJ75n)QS=Yy_Cd~Ls+ z0$o^#fq?;JCb{|zq3%M7J5b((TGWSXJ=iW}Axo%!17tx428MZ1{h;tgmVyd{!vZAk z1l12>BjbHAg~) +#include + +// A simplified placeholder for the Initial Permutation +static uint64_t initial_permutation(uint64_t message) { + // Apply an initial permutation (just a placeholder for now) + return message; // In a real implementation, this would rearrange the bits +} + +// A simplified placeholder for the Final Permutation +static uint64_t final_permutation(uint64_t message) { + // Apply the final permutation (just a placeholder for now) + return message; // In a real implementation, this would rearrange the bits +} + +// A simplified placeholder for the Feistel function used in DES rounds +static uint32_t feistel_function(uint32_t half_block, uint64_t subkey) { + // Apply an expansion, substitution, and permutation (placeholder) + return half_block ^ (uint32_t)(subkey); // Simplified XOR with the key +} + +// A simplified function to split the message into left and right halves +static void split_message(uint64_t message, uint32_t *left, uint32_t *right) { + *left = (uint32_t)(message >> 32); + *right = (uint32_t)(message & 0xFFFFFFFF); +} + +// A simplified function to merge left and right halves into one message +static uint64_t merge_message(uint32_t left, uint32_t right) { + return ((uint64_t)left << 32) | (uint64_t)right; +} + +// The main DES encryption function +void des_encrypt(unsigned long long *message, unsigned long long key) { + // Apply the initial permutation + *message = initial_permutation(*message); + + uint32_t left, right; + split_message(*message, &left, &right); + + // Perform 16 rounds of the Feistel function (simplified for now) + for (int i = 0; i < 16; i++) { + uint32_t temp = right; + right = left ^ feistel_function(right, key); // Simplified function + left = temp; + } + + // Merge the halves back together + *message = merge_message(left, right); + + // Apply the final permutation + *message = final_permutation(*message); +} + +// The main DES decryption function (similar to encryption, but reverse) +void des_decrypt(unsigned long long *message, unsigned long long key) { + // Apply the initial permutation + *message = initial_permutation(*message); + + uint32_t left, right; + split_message(*message, &left, &right); + + // Perform 16 rounds of the Feistel function (reversed for decryption) + for (int i = 0; i < 16; i++) { + uint32_t temp = left; + left = right ^ feistel_function(left, key); // Simplified function + right = temp; + } + + // Merge the halves back together + *message = merge_message(left, right); + + // Apply the final permutation + *message = final_permutation(*message); +} diff --git a/Data-Encryption-Standard/src/main.c b/Data-Encryption-Standard/src/main.c new file mode 100644 index 0000000..5874917 --- /dev/null +++ b/Data-Encryption-Standard/src/main.c @@ -0,0 +1,25 @@ +#include "des.h" +#include + +int main() { + unsigned long long message; + unsigned long long key; + + // Ask for a message and key (both as integers for simplicity) + printf("Enter a message to encrypt (as a 64-bit integer): "); + scanf("%llu", &message); + + printf("Enter a key (as a 64-bit integer): "); + scanf("%llu", &key); + + // Encrypt the message + des_encrypt(&message, key); + printf("Encrypted message: %llu\n", message); + + // Decrypt the message + des_decrypt(&message, key); + printf("Decrypted message: %llu\n", message); + + return 0; +} + diff --git a/Diffie-Hellman-Key-Exchange/README.md b/Diffie-Hellman-Key-Exchange/README.md new file mode 100644 index 0000000..6d438d4 --- /dev/null +++ b/Diffie-Hellman-Key-Exchange/README.md @@ -0,0 +1,14 @@ +# Diffie-Hellman Key Exchange + +## Description +This project implements a basic version of the Diffie-Hellman key exchange algorithm, allowing two parties (Alice and Bob) to agree on a shared secret over an insecure channel. + +## How to Build +1. Navigate to the `build` directory. +2. Run `make` to compile the project. + +## How to Run +1. After building, run the `diffie_hellman` executable using `./diffie_hellman`. + +## How to Clean +- Run `make clean` to remove all compiled files. diff --git a/Diffie-Hellman-Key-Exchange/build/Makefile b/Diffie-Hellman-Key-Exchange/build/Makefile new file mode 100644 index 0000000..a1657e2 --- /dev/null +++ b/Diffie-Hellman-Key-Exchange/build/Makefile @@ -0,0 +1,27 @@ +# Variables +CC = gcc +CFLAGS = -I../include -Wall -Wextra +OBJDIR = ../obj +SRCDIR = ../src +BINDIR = ../build + +# Source files +SOURCES = $(SRCDIR)/main.c $(SRCDIR)/diffie_hellman.c +OBJECTS = $(OBJDIR)/main.o $(OBJDIR)/diffie_hellman.o + +# Build target +TARGET = diffie_hellman + +# Rules +all: $(BINDIR)/$(TARGET) + +$(BINDIR)/$(TARGET): $(OBJECTS) + $(CC) $(OBJECTS) -o $(BINDIR)/$(TARGET) + +$(OBJDIR)/%.o: $(SRCDIR)/%.c + $(CC) $(CFLAGS) -c $< -o $@ + +clean: + rm -f $(OBJDIR)/*.o $(BINDIR)/$(TARGET) + +.PHONY: all clean diff --git a/Diffie-Hellman-Key-Exchange/build/diffie_hellman b/Diffie-Hellman-Key-Exchange/build/diffie_hellman new file mode 100755 index 0000000000000000000000000000000000000000..0e1064bc4a682466bad7b6a5303941b375956146 GIT binary patch literal 16264 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 +#include + +// Generate the public key: A = g^a mod p +unsigned long long generate_public_key(unsigned long long base, unsigned long long private_key, unsigned long long prime) { + unsigned long long result = 1; + for (unsigned long long i = 0; i < private_key; i++) { + result = (result * base) % prime; + } + return result; +} + +// Generate the shared secret: s = B^a mod p +unsigned long long generate_shared_secret(unsigned long long received_public_key, unsigned long long private_key, unsigned long long prime) { + unsigned long long result = 1; + for (unsigned long long i = 0; i < private_key; i++) { + result = (result * received_public_key) % prime; + } + return result; +} diff --git a/Diffie-Hellman-Key-Exchange/src/main.c b/Diffie-Hellman-Key-Exchange/src/main.c new file mode 100644 index 0000000..d852856 --- /dev/null +++ b/Diffie-Hellman-Key-Exchange/src/main.c @@ -0,0 +1,42 @@ +#include "diffie_hellman.h" +#include +#include +#include + +int main() { + // Publicly agreed upon base (g) and prime (p) + unsigned long long base = 5; + unsigned long long prime = 23; + + // Private keys chosen by Alice and Bob (should be random in practice) + unsigned long long alice_private_key, bob_private_key; + srand(time(NULL)); + alice_private_key = rand() % (prime - 1) + 1; // Random private key for Alice + bob_private_key = rand() % (prime - 1) + 1; // Random private key for Bob + + printf("Alice's private key: %llu\n", alice_private_key); + printf("Bob's private key: %llu\n", bob_private_key); + + // Generate public keys + unsigned long long alice_public_key = generate_public_key(base, alice_private_key, prime); + unsigned long long bob_public_key = generate_public_key(base, bob_private_key, prime); + + printf("Alice's public key: %llu\n", alice_public_key); + printf("Bob's public key: %llu\n", bob_public_key); + + // Exchange public keys and generate shared secrets + unsigned long long alice_shared_secret = generate_shared_secret(bob_public_key, alice_private_key, prime); + unsigned long long bob_shared_secret = generate_shared_secret(alice_public_key, bob_private_key, prime); + + printf("Alice's shared secret: %llu\n", alice_shared_secret); + printf("Bob's shared secret: %llu\n", bob_shared_secret); + + // Verify if shared secrets match + if (alice_shared_secret == bob_shared_secret) { + printf("Key exchange successful! Shared secret: %llu\n", alice_shared_secret); + } else { + printf("Key exchange failed.\n"); + } + + return 0; +} diff --git a/Elliptic-Curve-Cryptography/README.md b/Elliptic-Curve-Cryptography/README.md new file mode 100644 index 0000000..cc9ad5b --- /dev/null +++ b/Elliptic-Curve-Cryptography/README.md @@ -0,0 +1,78 @@ +# Elliptic Curve Cryptography (ECC) Project + +## Introduction + +This project implements a basic Elliptic Curve Cryptography (ECC) system in C. ECC is a type of public key encryption based on the mathematics of elliptic curves, which provides the same level of security as other public key cryptosystems (like RSA) but with smaller key sizes. + +## How It Works + +Elliptic curves are defined by equations of the form: + +y² = x³ + ax + b (mod p) + +vbnet + + +Where: +- `a` and `b` are constants defining the curve. +- `p` is the prime modulus. +- Points on the curve follow specific rules for addition and scalar multiplication. + +### Encryption and Decryption Steps: +1. **Key Generation**: + - The private key is a random number. + - The public key is computed as a point on the elliptic curve by multiplying the private key with a generator point. +2. **Encryption**: + - A random number `k` is generated. + - Two values are computed: `C1 = kG` (a point on the curve) and `C2 = plaintext XOR kP.x` (where `P` is the recipient's public key). +3. **Decryption**: + - The recipient computes the shared secret `dC1`, where `d` is their private key. + - The plaintext is recovered by XOR'ing `C2` with the shared secret's x-coordinate. + +## Expected Output + +Here is an example of the output: + +Private Key: 3 Public Key: (38, 59) Plaintext: 42 Ciphertext: (C1: 1, 59), C2: 59 Decrypted: 42 + +markdown + + +The **decrypted message** should always match the **original plaintext**. + +## How to Build and Run + +1. To build the project, run: + ```bash + make + ``` + +2. To execute the ECC encryption program: + ```bash + ./ecc + ``` + +3. To clean the build: + ```bash + make clean + ``` + +## File Structure +- `src/`: Source code for the ECC implementation. +- `include/`: Header files. +- `build/`: Compiled binary. +- `obj/`: Object files. + +## Elliptic Curve Parameters + +For simplicity, this implementation uses a small prime `p = 97` and a small generator point `(3, 6)` on the elliptic curve `y² = x³ + 2x + 3`. In real-world applications, much larger prime values and more complex elliptic curves are used for better security. + +## Future Work + +In the future, this project could be extended by: +- Supporting larger prime numbers and more complex elliptic curves. +- Implementing more advanced elliptic curve encryption algorithms such as Elliptic Curve Diffie-Hellman (ECDH) or Elliptic Curve Digital Signature Algorithm (ECDSA). + +## License + +This project is open-source and available under the MIT license. diff --git a/Elliptic-Curve-Cryptography/build/Makefile b/Elliptic-Curve-Cryptography/build/Makefile new file mode 100644 index 0000000..5ad85e9 --- /dev/null +++ b/Elliptic-Curve-Cryptography/build/Makefile @@ -0,0 +1,18 @@ +CC = gcc +CFLAGS = -I../include -Wall -Wextra +OBJDIR = ../obj +BINDIR = ../build + +all: $(BINDIR)/ecc + +$(BINDIR)/ecc: $(OBJDIR)/main.o $(OBJDIR)/ecc.o + $(CC) $(OBJDIR)/main.o $(OBJDIR)/ecc.o -o $(BINDIR)/ecc + +$(OBJDIR)/main.o: ../src/main.c ../include/ecc.h + $(CC) $(CFLAGS) -c ../src/main.c -o $(OBJDIR)/main.o + +$(OBJDIR)/ecc.o: ../src/ecc.c ../include/ecc.h + $(CC) $(CFLAGS) -c ../src/ecc.c -o $(OBJDIR)/ecc.o + +clean: + rm -f $(OBJDIR)/*.o $(BINDIR)/ecc diff --git a/Elliptic-Curve-Cryptography/build/ecc b/Elliptic-Curve-Cryptography/build/ecc new file mode 100755 index 0000000000000000000000000000000000000000..dacbb69d710e802f2f962b4224a166b717095d4b GIT binary patch literal 16304 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 Pu`w_(NTF#!<1zpM&o~nv literal 0 HcmV?d00001 diff --git a/Elliptic-Curve-Cryptography/include/ecc.h b/Elliptic-Curve-Cryptography/include/ecc.h new file mode 100644 index 0000000..36a55c9 --- /dev/null +++ b/Elliptic-Curve-Cryptography/include/ecc.h @@ -0,0 +1,35 @@ +#ifndef ECC_H +#define ECC_H + +#include + +// Struct for representing a point on the elliptic curve +typedef struct { + uint64_t x; + uint64_t y; +} ECPoint; + +// Define an elliptic curve +typedef struct { + uint64_t a; + uint64_t b; + uint64_t p; // Prime modulus + ECPoint generator; // Generator point + uint64_t n; // Order of the curve +} EllipticCurve; + +// Key pair +typedef struct { + uint64_t private_key; + ECPoint public_key; +} ECCKeyPair; + +// Function declarations +ECPoint ecc_point_add(ECPoint P, ECPoint Q, EllipticCurve curve); +ECPoint ecc_point_double(ECPoint P, EllipticCurve curve); +ECPoint ecc_scalar_mult(uint64_t k, ECPoint P, EllipticCurve curve); +ECCKeyPair ecc_generate_keypair(EllipticCurve curve); +void ecc_encrypt(uint64_t plaintext, ECPoint public_key, EllipticCurve curve, ECPoint *C1, uint64_t *C2); +uint64_t ecc_decrypt(ECPoint C1, uint64_t C2, uint64_t private_key, EllipticCurve curve); + +#endif diff --git a/Elliptic-Curve-Cryptography/obj/ecc.o b/Elliptic-Curve-Cryptography/obj/ecc.o new file mode 100644 index 0000000000000000000000000000000000000000..b9dd9f3642a654b1ca26c0bb81adf8f41e4350fd GIT binary patch literal 3696 zcmb<-^>JfjWMqH=Mg}_u1P><4z)--AU^{@B4h%dD+zg=}oliYFYfpG|mLBlvc0J(H z>H5Osxa$v)5|87qA3$b#G}j(rEREd(5_?_X(d~L-7l`Tcy%ePU0aV)!G>K4KRmi!L25pDG}oSBEMM%=T>F8clEb6h z^@Rtc>j#f+*AKCWL2eB8Xny12(fPr%^M_C8F`v%!9-YU*ZU(zObc08y?+&m-S`U

9k8WQ9kM39rk4_Gc&Ik^VZeInD?pO_vP7eW(&Ik#QZeIhB z?pOU&hH+b*Is}_toew+%R3Apr-XuBtKh+S2<+C*%O0ACAqItR@aT4h zN*n+MQg^9>N9P4-h=23wyx`G!&ZG1A3#Who|9kMS2Wx}Me)Q-JeE|+T{`ChuIzeWm zm;^I-1K3<&By&H4&2_!t(G3m+sIChjb^PnWWo0(8Wjp{01p$v<878pbyF*WSFkbTLJm%4P z{YCU&;=I|*1JZoJqgRB%qw|D^<^@o2BEsc@M<)$@=K;w&7d<*Zcy#`PcyfbBXXp-( zS?otDf?ph0v&H@FG&I%2%3vT*!p7-fI z2C=vKh=E6^>jOx_D1}52%xFrIG0Y<#7jsX5@-72^tM32*|2?{0A9!?w5)5)8i16sF zT>){=43BPK3q-VlRF-OZbccex@q)Yz1~C}o(F-1(p`eub!lM(E^TAOLDqnVZbb=DL z?+S1s&>gzNqm$92GZ0kJ9PsFL6!7SFU4fc#L2f<)j@N4*ou9zQf#S8(_kd5QD?L2Z z?Rx<3$Wm}A=FweC#UQ%CzwLmBvFiy)IkCc{Q(yvW2v}eiw--D*Yj1dThMw@~^gZCw z4NXtowFfAVIcO4feE@S7xENt@cXqZ?&~Qmj%1q2tFf`IL(lgLCG|_}I85l%Bxr~8< zfw3xxfw4k>QJROHV*(=sgA4-%gQS;$2uD7FHYR6YHm3PJ>>LaX3JeSkHXv~Z28J!5 zN)9IP+RV(niV?0R0jlO6h(=PwbOo#gY)%VEj)8$e9o-yRggGmqYPNuAWOG&_%sB&+ zV_;xlLNkZy2SUvUsG1%SjciU6L=8w78wMH4!tn7wHaTW2Ee3XwJCMY|VaUM1Ak4tP zAjH7P0ONzhj)8$e5h@dED&*UxG*payp;UXq#THJadKi#Vo`i#4SLULCrx{KM_eBS^aYy;&mWJP;)>`nE9am0`eaydO;Y(24P5Bl7Rsv2Ewp( zkphwgry+cOy10NQ4vYUUXyUN=XV5FI%q>YwV$drtDT2@$Fji4& zPNH5(YDEcyUP@v~B7yo1`rpd7nBx2LJ}Z? zfq_8{R8}%DFhG+dRFr|?KAOES36L2uHi*_?U|;~5Nv?iFsQm^Y!;mn{eo*)z3ByYu zm^-YX`jORu*#C)izduwzD6N9@!7-@71C>26i=Yx9ze1T{$_q#MXK;a~8DQl+DEvW2 z!t}$!A7ng+-5`6R3OPUu7#J8p#(}arRG0y#A7n0i*n@1A07)<~FqD8eNEm7yTtpB{ S+=CjwZ`JfF`1 literal 0 HcmV?d00001 diff --git a/Elliptic-Curve-Cryptography/obj/main.o b/Elliptic-Curve-Cryptography/obj/main.o new file mode 100644 index 0000000000000000000000000000000000000000..90fa8f8470097bd5e419dcaa4163d7a44ee8d7d3 GIT binary patch literal 2320 zcmb<-^>JfjWMqH=Mg}_u1P><4z;J;T!FB*M9T<2Sco;%GI-dr6G`{IzU|{e#?z({q zLhoRP&<7GB^a&{c0vm*X17w^>Z|DS%<~If&oew;^eK&Y?$L{dx;PB}7J>bzD zd%~mBL%^dmLc*il_ku@v>n}i#@Mu0_;L+_m!K3q-M=!`o29M6; zJ3ulJ>F&@49^I}pa7iC`eW3+%Pq*s}97=q8TPyzm|L@c5+u+e%I>Q5OVC@U?TSp-BdFfcGy1u-yI2rx?XuyagcWMEKXU|^7e%H0JeWJf-MHYR6Y zHjidz<_nBG>>N-@927_k3&Y3%*rb`U<_rb~W(IK5L(u}VMhHng*ewhU47>~s3<4-B zAsi(f;+iu}bFo1pc=RXAWK*d4%9F(VF;xnP*AoZX;4ijGu6^E(kgYvKs%Y-5dpwBm)BjNIeKcxeN??#g(}wiAfB4#U(`$Is?WkO3g{s17#5g zy_Cd~L?3=9mQ zum;P62nGfQP<(@wfYKIJ2u#VM1SVJrOn}sa8Bjt8Y9_h*4WaHrw@v{nPztpNM#0<< z<6A=Y8^8ph^i-&RQ20WHz!c2=Fxm;KA1sMPY=!Da5&|<}`oJ6p28M8`estwKpaSUe zg6{qx9Pt+bE#f4g7J=dqq!)xiLNIZVd!SZEh74@ASTAP)T*Q1`>~FHAkUegFjXc +#include + +// Modular inverse using extended Euclidean algorithm +static uint64_t mod_inverse(uint64_t a, uint64_t m) { + int64_t m0 = m, t, q; + int64_t x0 = 0, x1 = 1; + + if (m == 1) + return 0; + + while (a > 1) { + q = a / m; + t = m; + m = a % m; + a = t; + t = x0; + x0 = x1 - q * x0; + x1 = t; + } + + if (x1 < 0) + x1 += m0; + + return x1; +} + +// Modular arithmetic: Add two points P + Q +ECPoint ecc_point_add(ECPoint P, ECPoint Q, EllipticCurve curve) { + ECPoint R; + if (P.x == 0 && P.y == 0) return Q; + if (Q.x == 0 && Q.y == 0) return P; + + if (P.x == Q.x && P.y == Q.y) { + return ecc_point_double(P, curve); // Doubling case + } + + uint64_t lambda = ((Q.y + curve.p - P.y) * mod_inverse((Q.x + curve.p - P.x) % curve.p, curve.p)) % curve.p; + R.x = (lambda * lambda + curve.p - P.x + curve.p - Q.x) % curve.p; + R.y = (lambda * (P.x + curve.p - R.x) + curve.p - P.y) % curve.p; + + return R; +} + +// Doubling case: 2P +ECPoint ecc_point_double(ECPoint P, EllipticCurve curve) { + ECPoint R; + uint64_t lambda = ((3 * P.x * P.x + curve.a) * mod_inverse(2 * P.y, curve.p)) % curve.p; + R.x = (lambda * lambda + curve.p - 2 * P.x) % curve.p; + R.y = (lambda * (P.x + curve.p - R.x) + curve.p - P.y) % curve.p; + + return R; +} + +// Scalar multiplication: kP (repeated point addition) +ECPoint ecc_scalar_mult(uint64_t k, ECPoint P, EllipticCurve curve) { + ECPoint R = {0, 0}; // Point at infinity + ECPoint temp = P; + + while (k > 0) { + if (k & 1) { + R = ecc_point_add(R, temp, curve); + } + temp = ecc_point_double(temp, curve); + k >>= 1; + } + + return R; +} + +// Key generation: Generate private and public key +ECCKeyPair ecc_generate_keypair(EllipticCurve curve) { + uint64_t private_key = rand() % curve.n; + ECPoint public_key = ecc_scalar_mult(private_key, curve.generator, curve); + ECCKeyPair keypair = {private_key, public_key}; + + return keypair; +} + +// ECC encryption: Encrypts the plaintext and returns C1 (curve point) and C2 (encrypted message) +void ecc_encrypt(uint64_t plaintext, ECPoint public_key, EllipticCurve curve, ECPoint *C1, uint64_t *C2) { + uint64_t k = rand() % curve.n; // Random scalar for encryption + *C1 = ecc_scalar_mult(k, curve.generator, curve); // C1 = kG + ECPoint shared_secret = ecc_scalar_mult(k, public_key, curve); // kP + + *C2 = plaintext ^ (shared_secret.x % 256); // XOR plaintext with shared secret's x-coordinate (mod 256) +} + +// ECC decryption: Takes C1 and C2 to recover the original plaintext +uint64_t ecc_decrypt(ECPoint C1, uint64_t C2, uint64_t private_key, EllipticCurve curve) { + ECPoint shared_secret = ecc_scalar_mult(private_key, C1, curve); // dC1 + + return C2 ^ (shared_secret.x % 256); // XOR with shared secret's x-coordinate to recover plaintext +} + diff --git a/Elliptic-Curve-Cryptography/src/ecc.c.bak b/Elliptic-Curve-Cryptography/src/ecc.c.bak new file mode 100644 index 0000000..cbb73c0 --- /dev/null +++ b/Elliptic-Curve-Cryptography/src/ecc.c.bak @@ -0,0 +1,92 @@ +#include "ecc.h" +#include +#include + +// Modular inverse using extended Euclidean algorithm +static uint64_t mod_inverse(uint64_t a, uint64_t m) { + int64_t m0 = m, t, q; + int64_t x0 = 0, x1 = 1; + + if (m == 1) + return 0; + + while (a > 1) { + q = a / m; + t = m; + m = a % m; + a = t; + t = x0; + x0 = x1 - q * x0; + x1 = t; + } + + if (x1 < 0) + x1 += m0; + + return x1; +} + +// Modular arithmetic: Add two points P + Q +ECPoint ecc_point_add(ECPoint P, ECPoint Q, EllipticCurve curve) { + ECPoint R; + if (P.x == Q.x && P.y == Q.y) { + return ecc_point_double(P, curve); // Doubling case + } + + uint64_t lambda = ((Q.y + curve.p - P.y) * mod_inverse((Q.x + curve.p - P.x) % curve.p, curve.p)) % curve.p; + R.x = (lambda * lambda + curve.p - P.x + curve.p - Q.x) % curve.p; + R.y = (lambda * (P.x + curve.p - R.x) + curve.p - P.y) % curve.p; + + return R; +} + +// Doubling case: 2P +ECPoint ecc_point_double(ECPoint P, EllipticCurve curve) { + ECPoint R; + uint64_t lambda = ((3 * P.x * P.x + curve.a) * mod_inverse(2 * P.y, curve.p)) % curve.p; + R.x = (lambda * lambda + curve.p - 2 * P.x) % curve.p; + R.y = (lambda * (P.x + curve.p - R.x) + curve.p - P.y) % curve.p; + + return R; +} + +// Scalar multiplication: kP (repeated point addition) +ECPoint ecc_scalar_mult(uint64_t k, ECPoint P, EllipticCurve curve) { + ECPoint R = {0, 0}; // Point at infinity + ECPoint temp = P; + + while (k > 0) { + if (k & 1) { + R = ecc_point_add(R, temp, curve); + } + temp = ecc_point_double(temp, curve); + k >>= 1; + } + + return R; +} + +// Key generation: Generate private and public key +ECCKeyPair ecc_generate_keypair(EllipticCurve curve) { + uint64_t private_key = rand() % curve.n; + ECPoint public_key = ecc_scalar_mult(private_key, curve.generator, curve); + ECCKeyPair keypair = {private_key, public_key}; + + return keypair; +} + +// Encryption using ECC +void ecc_encrypt(uint64_t plaintext, ECPoint public_key, EllipticCurve curve, ECPoint *C1, uint64_t *C2) { + uint64_t k = rand() % curve.n; + *C1 = ecc_scalar_mult(k, curve.generator, curve); // C1 = kG + ECPoint shared_secret = ecc_scalar_mult(k, public_key, curve); // kP + + *C2 = plaintext ^ shared_secret.x; // XOR plaintext with shared secret's x-coordinate +} + +// Decryption using ECC +uint64_t ecc_decrypt(ECPoint C1, uint64_t C2, uint64_t private_key, EllipticCurve curve) { + ECPoint shared_secret = ecc_scalar_mult(private_key, C1, curve); // dC1 + + return C2 ^ shared_secret.x; // XOR with shared secret to recover plaintext +} diff --git a/Elliptic-Curve-Cryptography/src/main.c b/Elliptic-Curve-Cryptography/src/main.c new file mode 100644 index 0000000..94dfb5f --- /dev/null +++ b/Elliptic-Curve-Cryptography/src/main.c @@ -0,0 +1,33 @@ +#include "ecc.h" +#include + +int main() { + // Define the elliptic curve + EllipticCurve curve = { + .a = 2, + .b = 3, + .p = 97, // Small prime for simplicity + .generator = {3, 6}, // Generator point + .n = 5 // Order of the generator + }; + + // Generate keypair for ECC + ECCKeyPair keypair = ecc_generate_keypair(curve); + printf("Private Key: %lu\n", keypair.private_key); + printf("Public Key: (%lu, %lu)\n", keypair.public_key.x, keypair.public_key.y); + + // Encrypt a message + uint64_t plaintext = 42; + printf("Plaintext: %lu\n", plaintext); + + ECPoint C1; + uint64_t C2; + ecc_encrypt(plaintext, keypair.public_key, curve, &C1, &C2); + printf("Ciphertext: (C1: %lu, %lu), C2: %lu\n", C1.x, C1.y, C2); + + // Decrypt the message + uint64_t decrypted = ecc_decrypt(C1, C2, keypair.private_key, curve); + printf("Decrypted: %lu\n", decrypted); + + return 0; +} diff --git a/README.md b/README.md new file mode 100644 index 0000000..3e7861a --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# cryptograph-projects Project + +This is a C project generated with the setup tool. diff --git a/Simple_Substitution/README.md b/Simple_Substitution/README.md new file mode 100644 index 0000000..da4eaa5 --- /dev/null +++ b/Simple_Substitution/README.md @@ -0,0 +1,15 @@ +# Simple Substitution Cipher + +## Description +A simple substitution cipher replaces each letter in the plaintext with another letter from the alphabet, based on a predetermined key. + +## How to Build +1. Navigate to the `build` directory. +2. Run `make` to compile the project. + +## How to Run +1. After building, you will find an executable named `substitution_cipher` in the `build` directory. +2. Run it using `./substitution_cipher`. + +## How to Clean +- Run `make clean` in the `build` directory to remove all compiled files. diff --git a/Simple_Substitution/build/Makefile b/Simple_Substitution/build/Makefile new file mode 100644 index 0000000..28b8c38 --- /dev/null +++ b/Simple_Substitution/build/Makefile @@ -0,0 +1,28 @@ +# Variables +CC = gcc +CFLAGS = -I../include -Wall -Wextra +OBJDIR = ../obj +SRCDIR = ../src +BINDIR = ../build + +# Source files +SOURCES = $(SRCDIR)/main.c $(SRCDIR)/substitution_cipher.c +OBJECTS = $(OBJDIR)/main.o $(OBJDIR)/substitution_cipher.o + +# Build target +TARGET = substitution_cipher + +# Rules +all: $(BINDIR)/$(TARGET) + +$(BINDIR)/$(TARGET): $(OBJECTS) + $(CC) $(OBJECTS) -o $(BINDIR)/$(TARGET) + +$(OBJDIR)/%.o: $(SRCDIR)/%.c + $(CC) $(CFLAGS) -c $< -o $@ + +clean: + rm -f $(OBJDIR)/*.o $(BINDIR)/$(TARGET) + +.PHONY: all clean + diff --git a/Simple_Substitution/build/substitution_cipher b/Simple_Substitution/build/substitution_cipher new file mode 100755 index 0000000000000000000000000000000000000000..13485a5b7777c1004e5e348aab80749369e09a47 GIT binary patch literal 16432 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 X5E%#wYQ|&JA7l=ZmqOEk#$^BiCJY%A literal 0 HcmV?d00001 diff --git a/Simple_Substitution/include/substitution_cipher.h b/Simple_Substitution/include/substitution_cipher.h new file mode 100644 index 0000000..2bcc581 --- /dev/null +++ b/Simple_Substitution/include/substitution_cipher.h @@ -0,0 +1,7 @@ +#ifndef SUBSTITUTION_CIPHER_H +#define SUBSTITUTION_CIPHER_H + +void substitution_encrypt(char *message, const char *key); +void substitution_decrypt(char *message, const char *key); + +#endif // SUBSTITUTION_CIPHER_H diff --git a/Simple_Substitution/obj/main.o b/Simple_Substitution/obj/main.o new file mode 100644 index 0000000000000000000000000000000000000000..e9ac87ddbcb09a73b8ddce1ebcae0176c5044644 GIT binary patch literal 2112 zcmb<-^>JfjWMqH=Mg}_u1P><4z`($YU^{@B4h*~uJPe^8oliX)-zYFLFnH_;40jC* zi467h*ySJK%;3>G z6>L9L9YTQzOyrmcHY>@~26pqw!>)NHsYMEj3c0Dp#fj;u3MKgpsd>pol?5eM3JhEf zt`K%=3QU2Of@(1rgG(w{3A!+YyR);Ef`&_KQf6YFf}xR~k)DCBp@}Ax2?`ky76B0q z3=E7_K@5x)0*ul;>>Lvq85m?3AQ&Vq0*Y8iK7lqSXI?gDenuX44v;Wb3{uL%@bN!3 zNoG(KV3A-(P9#uykPSje>cMVcU|`^7U|V z@d)))5R_(OU|?WoU|{(39|Gc`;w;dt1rtw$ii6a%A*ru|ii6a%BZ+rF#X;&p=1W5P zlc6+7Jtz)f=5Ij~=R`8+C{!F~jx>~i2}*;^0cA~?Ij@n#xsc5H0~LpvV+7@Mf)W%1 z0|UA_p!fqR0jURJ5F3p3iYs$V5|bG8ic5+hbOwx7l$w*MSCU#$!l0LuSdz$~msDKL zpjVU+;Uwqh=BDPAFzDswm!#^s`-SQjmn0@J4_Cw7RCnApl}9-2~0gm41^Ovk;%Zo04i8Pd{7vJ^n&6N#FqdO3=9lv zpga#vTTme|6#`NWW}y=3!a58L3?MV1*1;7MtKSf6KT6y&FfhRM`@&6xFwpI{gz7hd zNW;m6P=%oIg$qK}g7{Er1}7vjkT?tq@M#S f2y!2Y55rL7U|a@4ENKTMIRoncL=XoFqw5C%aYHoY literal 0 HcmV?d00001 diff --git a/Simple_Substitution/obj/substitution_cipher.o b/Simple_Substitution/obj/substitution_cipher.o new file mode 100644 index 0000000000000000000000000000000000000000..c36069d3dc790c75335d17370a96a167abcedea3 GIT binary patch literal 2224 zcmb<-^>JfjWMqH=Mg}_u1P><4z_5W8!FB*M9T<2RxEVq{I-hzpzY*yC(c$`sf1m50 z&f_mY(okOW3&)d(p=uO7I%{8ebe29i?)nF$9Z!N2d42je9V#tZ!08Thv!P-S3YU}!zS-_pszz|igb$0PZIN4M(>ko-0V{(T2J zkH0AV|Nnod>kr~hWCWR5BGm2r17g|(h-t5-&_y8TgWQbb%nqhz*FTKtj%hi-->UZi z|NjXS;68Wo=&U{A(OG%`>hsqc-L8LnJsja$4?t|@-*=$-g=6O_j~N{ytQSCrH`o4= zth;pF^#{oEmzz)m><1*kPT&o&l3KWDPQWecJpRJvA1JWCAOee!X^_C;>303%F@t}b z3+si~A_z8e03jI!3ZNg1=nen{kQp?97~GwmtrRp|Qj;Rfq_90l;C0V%rcB%1yDJ33Z#^U;p2aFaS)#wOU@BzU|?WE5(m4L zfq_Alfq_8)qzMh{GB7X*F)%W~)Pdd3z`)>yLwx`a@d&6nav%r8{0OqExHPG_B(tQn zBr`uRJ~^`>Beh5`nISDRFD1Spzc>>l%uteFT2PQ$#DJnUH7~iSvY><^K0djmvLH1+ zDLyAZnV}>UIhf(ke+X~{xdkf5#=rm=V<|OKsq*jzL=%pl=J!jH*Yo7bcEwzYf$)a`hWR?Kgl~0HtB} zgTeIjg0~gdDbp0T6p-Q1DA=C$`U@n9UCqeeXISdR8 Zf(#4{P^HMi3;|I0N1})_AeEdD2>{=oq2B-i literal 0 HcmV?d00001 diff --git a/Simple_Substitution/src/main.c b/Simple_Substitution/src/main.c new file mode 100644 index 0000000..0232268 --- /dev/null +++ b/Simple_Substitution/src/main.c @@ -0,0 +1,22 @@ +#include "substitution_cipher.h" +#include +#include + +int main() { + char message[256]; + char key[27] = "QWERTYUIOPLKJHGFDSAZXCVBNM"; // Simple substitution key + + printf("Enter a message to encrypt: "); + fgets(message, sizeof(message), stdin); + message[strcspn(message, "\n")] = '\0'; // Remove the newline character + + // Encrypt the message + substitution_encrypt(message, key); + printf("Encrypted message: %s\n", message); + + // Decrypt the message to verify it works + substitution_decrypt(message, key); + printf("Decrypted message: %s\n", message); + + return 0; +} diff --git a/Simple_Substitution/src/substitution_cipher.c b/Simple_Substitution/src/substitution_cipher.c new file mode 100644 index 0000000..218f023 --- /dev/null +++ b/Simple_Substitution/src/substitution_cipher.c @@ -0,0 +1,36 @@ +#include "substitution_cipher.h" +#include +#include // for isalpha, toupper + +// Helper function to find the position of a character in the alphabet +static int find_position(char c) { + c = toupper(c); + return c - 'A'; +} + +// Encrypt the message using the provided key +void substitution_encrypt(char *message, const char *key) { + for (int i = 0; message[i] != '\0'; i++) { + if (isalpha(message[i])) { + int pos = find_position(message[i]); + //char base = isupper(message[i]) ? 'A' : 'a'; + message[i] = isupper(message[i]) ? key[pos] : tolower(key[pos]); + } + } +} + +// Decrypt the message using the provided key +void substitution_decrypt(char *message, const char *key) { + char reverse_key[26]; + for (int i = 0; i < 26; i++) { + reverse_key[key[i] - 'A'] = 'A' + i; + } + + for (int i = 0; message[i] != '\0'; i++) { + if (isalpha(message[i])) { + int pos = find_position(message[i]); + //char base = isupper(message[i]) ? 'A' : 'a'; + message[i] = isupper(message[i]) ? reverse_key[pos] : tolower(reverse_key[pos]); + } + } +} diff --git a/Vigenère_Cipher/README.md b/Vigenère_Cipher/README.md new file mode 100644 index 0000000..1a438fb --- /dev/null +++ b/Vigenère_Cipher/README.md @@ -0,0 +1,21 @@ +# Vigenère Cipher + +## Description +This project implements a Vigenère cipher to demonstrate basic encryption and decryption using a keyword-based shifting approach. + +## Directory Structure +- `include/`: Contains the header files. +- `src/`: Contains the source code files (`main.c` and `vigenere_cipher.c`). +- `obj/`: Contains the compiled object files. +- `build/`: Contains the Makefile and the compiled binary. + +## How to Build +1. Navigate to the `build` directory. +2. Run `make` to compile the project. + +## How to Run +1. After building, you will find an executable named `vigenere_cipher` in the `build` directory. +2. Run it using `./vigenere_cipher`. + +## How to Clean +- Run `make clean` in the `build` directory to remove all compiled files. diff --git a/Vigenère_Cipher/build/Makefile b/Vigenère_Cipher/build/Makefile new file mode 100644 index 0000000..b592372 --- /dev/null +++ b/Vigenère_Cipher/build/Makefile @@ -0,0 +1,28 @@ +# Variables +CC = gcc +CFLAGS = -I../include -Wall -Wextra +OBJDIR = ../obj +SRCDIR = ../src +BINDIR = ../build + +# Source files +SOURCES = $(SRCDIR)/main.c $(SRCDIR)/vigenere_cipher.c +OBJECTS = $(OBJDIR)/main.o $(OBJDIR)/vigenere_cipher.o + +# Build target +TARGET = vigenere_cipher + +# Rules +all: $(BINDIR)/$(TARGET) + +$(BINDIR)/$(TARGET): $(OBJECTS) + $(CC) $(OBJECTS) -o $(BINDIR)/$(TARGET) + +$(OBJDIR)/%.o: $(SRCDIR)/%.c + $(CC) $(CFLAGS) -c $< -o $@ + +clean: + rm -f $(OBJDIR)/*.o $(BINDIR)/$(TARGET) + +.PHONY: all clean + diff --git a/Vigenère_Cipher/build/vigenere_cipher b/Vigenère_Cipher/build/vigenere_cipher new file mode 100755 index 0000000000000000000000000000000000000000..3d1ea3a0633d133e354cbb42cadf9e01f96df787 GIT binary patch literal 16360 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�X9uPtVCuO3aB*DakJ?j!!JDU`Wo-EyzhNNlno+z^($ca6dCXv8X7q zGCno0q^Oc1ttc@!H9n;@H@A`@J|2k|pP83gf}#|(4?r)Op)4~!H7~U&H9k4BAS1O% zFPR}e-Yv+{*EQbN&m}&dA>Jj@&(YV@nIS&j-7hrW)dMQ);S$6U@9yL8GF<^bPKfPdcrct-N!Ng@N-zo1O-V32Ci9tadU@Wu%gk@$F!1rWDl>|2OWDbA12NX$zC?P>7zj|aOi zzO*W*gv}pqCPKfyUWTgEVsK$a~5VTZ0=Qb=PHDh8rJtIRxgTZ^ zjILu~0IeB>`ybYRhS9L<3*G%N`+K2vAkJz~~uh2^MNR$S5%025uKZ=I%fOuyz-W z<^%~MVKn0y_CWQ+;tzcvZ4Q!N5EETLXigC1ewcn(yA?)*_78&e!7#f1OKA45fM!@2 z{RXBHO2fhp%4N92zyMke3*OHO5`*oBgY7FtR}bUE=obtOpxy{vKde7-1G>)_rVeB_ z2*da=`U`a46xuCkIpYClvt%vc7PetEbEgaHjsP`3vx0OG^a9#{ZMBtQ+cfF?Lu1_p3n73ObHSprfD n${#SdgZMB!!vw-AMKc^^A4CR1f|}*n^z)iSsBD1 literal 0 HcmV?d00001 diff --git a/Vigenère_Cipher/include/vigenere_cipher.h b/Vigenère_Cipher/include/vigenere_cipher.h new file mode 100644 index 0000000..732b133 --- /dev/null +++ b/Vigenère_Cipher/include/vigenere_cipher.h @@ -0,0 +1,7 @@ +#ifndef VIGENERE_CIPHER_H +#define VIGENERE_CIPHER_H + +void encrypt(char *plaintext, const char *key); +void decrypt(char *ciphertext, const char *key); + +#endif // VIGENERE_CIPHER_H diff --git a/Vigenère_Cipher/obj/main.o b/Vigenère_Cipher/obj/main.o new file mode 100644 index 0000000000000000000000000000000000000000..0bf36a6bbd1b1c84ead9a0bc79b9c030cac41e11 GIT binary patch literal 2256 zcmb<-^>JfjWMqH=Mg}_u1P><4z%YRo!FB*M9T<2Sco;%GI-hzpzF}ZuVDRV#tMTYO zz5}G-1&HwI76ntitqlMF|KA5P+N1M0L<%D2(F;-0c?~9Utc4Y%n2>q@u$cGn|9|Y} z{rmr)!J~I716TprEglF9J)kb>JciW^8T1O`3k9d z$wid~B~}UyTnrHDl8jWCXl8z%LUwAUl>&n+L|JMIOs|!KYB3jsODb45x-f&gv$K_g zhD&NvW@4U#p^=`Eo`J5Ri6)fEAOea81_lPksvri&3IRrG9(Ilij0_Ai3=j;GRsco3 zBcDJUlQSwk z2%xBha6taRCN70Ty#fw#4IJVIIK&xp6EpMllED;1K~ZL2Ng6|ONlIoOLt1)jNijol zNl|ifK^_A%av4$}(Zs+9aW*J_FfcPPF#P!s0n$)$76t}zsKCUPpyEsn3=C{Y>dm0y zAoc7>;x15ekb02$l2E=slm@8>g)z+hIH)*GJXF^k1{DXX zM|RH?s5nSHvU}!3#X;(k-E#m*oD<1k7op-Xb720z2NegIgY3@lNa9>b=5T-#Dgy&N z{C%P7M4{s7=77=*ND0VZ5C*ZqSg*J;w3S?I8;Bn`(gSmz`76w zD69}X28JL81_o^LCjiPU3=9mgcml;ANG}M3^uxqK?m@R3B(DG!gyko0s6FWVL3tQG i?m+rApn~Y`2iXUbhhaf1X$K^y0d;>Oh=YXD^#cH}w@Zuw literal 0 HcmV?d00001 diff --git a/Vigenère_Cipher/obj/vigenere_cipher.o b/Vigenère_Cipher/obj/vigenere_cipher.o new file mode 100644 index 0000000000000000000000000000000000000000..e1f28cffd8cf675e8f95532ed316b519aa28b88e GIT binary patch literal 2200 zcmb<-^>JfjWMqH=Mg}_u1P><4z%YXq!FB*M9T<2RxEVq{I-hzpzcKLWti9pUS$e^v z+x3D+=kXUHC7rHcj=TN=v5vd`08uYNBv{I$o1r`Ok4N$;kM7VL9*n2>w+VUh@4Mu| zc*%qD0{?af{_O`;8CVz?S`YBI>}OzLAYKy_NK*;>jzk6qhS#h+92poGI$S?@yZ)H@ zz4lAz1&?Hi6B#e?Z)4!!cL3_t<`;>bu5Y?s|3Kt#fLsBRzrerG^|R)oZr3-AV6B;# z{NEh$^EmiQ;ovXk&VvVk%4?p=J|(4jqVo{{HrLO+JWMENbe`%EXm;iV&E11`hGVNaAb^3=A;!aiD<2Vtyr(II{WcaENmKtUjZV_0Fnk_ zD3<|J)-k}vVd2K0S6rD}l95(d4z{E}2XcfU~G;*!MVYz95B^3;s@w4%h^RG7V#(jfnUf&k=4WV2xY=|}b? zC_f-8f~Gf67{S!Tq&+}_3=9khpaPswy&OQ`hT zFKAjv4}T6&B4=P=fcXm){_IHlVc`$*2h=KLV;MZ40Sb#hE^s*n32Tr-n0}DCP^BPY jIOc%HKf1d>_Q4e~Ffa&0%|#Xiu`QtPj|6d$FuHyK_SUjf literal 0 HcmV?d00001 diff --git a/Vigenère_Cipher/src/main.c b/Vigenère_Cipher/src/main.c new file mode 100644 index 0000000..2e02f30 --- /dev/null +++ b/Vigenère_Cipher/src/main.c @@ -0,0 +1,26 @@ +#include "vigenere_cipher.h" +#include +#include + +int main() { + char message[256]; + char key[256]; + + printf("Enter a message to encrypt: "); + fgets(message, sizeof(message), stdin); + message[strcspn(message, "\n")] = '\0'; // Remove newline character + + printf("Enter the encryption key: "); + fgets(key, sizeof(key), stdin); + key[strcspn(key, "\n")] = '\0'; // Remove newline character + + // Encrypt the message + encrypt(message, key); + printf("Encrypted message: %s\n", message); + + // Decrypt the message + decrypt(message, key); + printf("Decrypted message: %s\n", message); + + return 0; +} diff --git a/Vigenère_Cipher/src/vigenere_cipher.c b/Vigenère_Cipher/src/vigenere_cipher.c new file mode 100644 index 0000000..9edbcf0 --- /dev/null +++ b/Vigenère_Cipher/src/vigenere_cipher.c @@ -0,0 +1,28 @@ +#include "vigenere_cipher.h" +#include +#include +#include + +void encrypt(char *plaintext, const char *key) { + int keyLen = strlen(key); + for (int i = 0, j = 0; plaintext[i] != '\0'; i++) { + if (isalpha(plaintext[i])) { + char base = islower(plaintext[i]) ? 'a' : 'A'; + int shift = (tolower(key[j % keyLen]) - 'a'); + plaintext[i] = (plaintext[i] - base + shift) % 26 + base; + j++; + } + } +} + +void decrypt(char *ciphertext, const char *key) { + int keyLen = strlen(key); + for (int i = 0, j = 0; ciphertext[i] != '\0'; i++) { + if (isalpha(ciphertext[i])) { + char base = islower(ciphertext[i]) ? 'a' : 'A'; + int shift = (tolower(key[j % keyLen]) - 'a'); + ciphertext[i] = (ciphertext[i] - base - shift + 26) % 26 + base; + j++; + } + } +} diff --git a/XOR_Encryption/README.md b/XOR_Encryption/README.md new file mode 100644 index 0000000..3893493 --- /dev/null +++ b/XOR_Encryption/README.md @@ -0,0 +1,21 @@ +# XOR Cipher + +## Description +This project implements a simple XOR cipher for encrypting and decrypting text using a key. XOR encryption is a symmetric operation, meaning the same function is used to both encrypt and decrypt data. + +## Directory Structure +- `include/`: Contains the header files. +- `src/`: Contains the source code files (`main.c` and `xor_cipher.c`). +- `obj/`: Contains the compiled object files. +- `build/`: Contains the Makefile and the compiled binary. + +## How to Build +1. Navigate to the `build` directory. +2. Run `make` to compile the project. + +## How to Run +1. After building, you will find an executable named `xor_cipher` in the `build` directory. +2. Run it using `./xor_cipher`. + +## How to Clean +- Run `make clean` in the `build` directory to remove all compiled files. diff --git a/XOR_Encryption/build/Makefile b/XOR_Encryption/build/Makefile new file mode 100644 index 0000000..b8c3618 --- /dev/null +++ b/XOR_Encryption/build/Makefile @@ -0,0 +1,27 @@ +# Variables +CC = gcc +CFLAGS = -I../include -Wall -Wextra +OBJDIR = ../obj +SRCDIR = ../src +BINDIR = ../build + +# Source files +SOURCES = $(SRCDIR)/main.c $(SRCDIR)/xor_cipher.c +OBJECTS = $(OBJDIR)/main.o $(OBJDIR)/xor_cipher.o + +# Build target +TARGET = xor_cipher + +# Rules +all: $(BINDIR)/$(TARGET) + +$(BINDIR)/$(TARGET): $(OBJECTS) + $(CC) $(OBJECTS) -o $(BINDIR)/$(TARGET) + +$(OBJDIR)/%.o: $(SRCDIR)/%.c + $(CC) $(CFLAGS) -c $< -o $@ + +clean: + rm -f $(OBJDIR)/*.o $(BINDIR)/$(TARGET) + +.PHONY: all clean diff --git a/XOR_Encryption/build/xor_cipher b/XOR_Encryption/build/xor_cipher new file mode 100755 index 0000000000000000000000000000000000000000..433f198a1c970b93c16aabb2e70a2ac752e0855e GIT binary patch literal 16416 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 literal 0 HcmV?d00001 diff --git a/XOR_Encryption/obj/xor_cipher.o b/XOR_Encryption/obj/xor_cipher.o new file mode 100644 index 0000000000000000000000000000000000000000..a1873bc3497b6604fc5e621517ffa522bc927620 GIT binary patch literal 1360 zcmb<-^>JfjWMqH=Mg}_u1P><4z!1QMU^{@B4h%dD+zg=}oliZQ-za!=*1quQEPde7 z?fSr@^Y{ypl1|qj$6fz`Sg&onUH^C_U-0O5ec{1)fq$Dpx9gvo-)nz#UVw-`0E=>< zs4_g)`Kd#o+4T=2iZK5+hL!`R>nBV&d6>c7+1W}#!zDE-GcixW&`8fn&p_AEL=(yc z*(?Gg7#J8BtAZF9D+Cy&dDuB7FfuU6FhDR!x)ww@@(HvtIrFkHRq(KLfCR8(P}s0A zeEg41mKjUP@i8zk2qB4s?P6eHP-0+U5Wr?gMSf9ya%MqBYLQ+t1BjEFmt0g?P!gY# z3Z@x~ONw$*^I%#fpbQoU1_luR^B)2fpyHrt17RqafkCghGPfi#i9xTpqzFQ1z*t48 zIf;5DsTCy*dMSw|i41y4#l;MI$@#gtsd*&~dU^RJse0~yp}NH-iOJavdSKK`e1_oQ2i)rhJk_M0aSqnl!j5T@PqNaaD@L2s70`F28BO6G^{{+Vd5ZV=yrqU zK@toM3>6>_0|NsW0|NsnjA8b}^n=U=i9?maDNvpVaWp{$5{4QJ7ZHS-3m1SgK0p;l NLisQXDh%T?002;Wj;a6v literal 0 HcmV?d00001 diff --git a/XOR_Encryption/src/main.c b/XOR_Encryption/src/main.c new file mode 100644 index 0000000..be557fd --- /dev/null +++ b/XOR_Encryption/src/main.c @@ -0,0 +1,54 @@ +#include "xor_cipher.h" +#include +#include + +// Function to display encrypted message in hexadecimal format +void print_hex(const char *data) { + for (int i = 0; data[i] != '\0'; i++) { + printf("%02x ", (unsigned char)data[i]); + } + printf("\n"); +} + +// Function to safely print decrypted message, replacing nulls with spaces +void print_decrypted_message(const char *data) { + for (int i = 0; data[i] != '\0'; i++) { + // If the character is NULL, print a space instead + putchar(data[i] == '\0' ? ' ' : data[i]); + } + printf("\n"); +} + +int main() { + char message[256]; + char key[256]; + + // Get the message to encrypt + printf("Enter a message to encrypt: "); + fgets(message, sizeof(message), stdin); + message[strcspn(message, "\n")] = '\0'; // Remove newline character + + // Get the encryption key + printf("Enter the encryption key: "); + fgets(key, sizeof(key), stdin); + key[strcspn(key, "\n")] = '\0'; // Remove newline character + + // Check if message or key is empty + if (strlen(message) == 0 || strlen(key) == 0) { + printf("Error: Message or key cannot be empty.\n"); + return 1; + } + + // Encrypt the message + xor_encrypt_decrypt(message, key); + printf("Encrypted message (hexadecimal): "); + print_hex(message); + + // Decrypt the message (using the same function, since XOR is symmetric) + xor_encrypt_decrypt(message, key); + printf("Decrypted message: "); + print_decrypted_message(message); + + return 0; +} + diff --git a/XOR_Encryption/src/xor_cipher.c b/XOR_Encryption/src/xor_cipher.c new file mode 100644 index 0000000..a4efb4c --- /dev/null +++ b/XOR_Encryption/src/xor_cipher.c @@ -0,0 +1,10 @@ +#include "xor_cipher.h" +#include +#include + +void xor_encrypt_decrypt(char *data, const char *key) { + int keyLength = strlen(key); + for (int i = 0; data[i] != '\0'; i++) { + data[i] ^= key[i % keyLength]; + } +} diff --git a/rsa-algorithms/README.md b/rsa-algorithms/README.md new file mode 100644 index 0000000..49bcc07 --- /dev/null +++ b/rsa-algorithms/README.md @@ -0,0 +1,3 @@ +# rsa-algorithms Project + +This is a C project generated with the setup tool. diff --git a/rsa-algorithms/build/Makefile b/rsa-algorithms/build/Makefile new file mode 100644 index 0000000..1de23cd --- /dev/null +++ b/rsa-algorithms/build/Makefile @@ -0,0 +1,28 @@ +# Variables +CC = gcc +CFLAGS = -I../include -Wall -Wextra +OBJDIR = ../obj +SRCDIR = ../src +BINDIR = ../build + +# Source files +SOURCES = $(SRCDIR)/main.c $(SRCDIR)/rsa.c +OBJECTS = $(OBJDIR)/main.o $(OBJDIR)/rsa.o + +# Build target +TARGET = rsa + +# Rules +all: $(BINDIR)/$(TARGET) + +$(BINDIR)/$(TARGET): $(OBJECTS) + $(CC) $(OBJECTS) -o $(BINDIR)/$(TARGET) + +$(OBJDIR)/%.o: $(SRCDIR)/%.c + $(CC) $(CFLAGS) -c $< -o $@ + +clean: + rm -f $(OBJDIR)/*.o $(BINDIR)/$(TARGET) + +.PHONY: all clean + diff --git a/rsa-algorithms/build/rsa b/rsa-algorithms/build/rsa new file mode 100755 index 0000000000000000000000000000000000000000..ea99719d9c043af6669f9eef75b0afac32c279bb GIT binary patch literal 16320 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 pP~Jn2JCK$QP(fc12ML4hL*g3LZ5;pr literal 0 HcmV?d00001 diff --git a/rsa-algorithms/obj/rsa.o b/rsa-algorithms/obj/rsa.o new file mode 100644 index 0000000000000000000000000000000000000000..81d21e89967573dca1d00d2b6a7e3af82a463c6b GIT binary patch literal 2528 zcmb<-^>JfjWMqH=Mg}_u1P><4z_5S~!FB*M9T<2Sco;%GI-h!U*1quQEPe1=(WBe- zfk&t7507rw7rQ{JJieDc@aPPE;L+{+!=uyng-3Jk1BTKYAo7LfHK4U2k}39`fi6 z{Q%PB(dl{u>aZ6c-L5x0_}9BW@aPUb0a5b+;-&>2&9yHW%h-2-T=81Uqq+76LnXgQ zcPPj+8$1{G#s~WmYA7=UIHf{)5K5eZfkB9Yk>Lx33-L1p1A`_51A_om z44DE&CN^k&WR`&CQuC6FDhnX&lvD^CWEw**)LxJ^AYcCZ4*{i6 zaTW#!22hy6#Osm7LFob}z8)$LGe-q%Is?OYs5rVg2a&{)%~62r1DONDP%ZW5kf6J}6=>PIej zK$7V055f_D2cYp+0n)_4zyOLrkX{f53BlqI}T1Q1Js$qGDiR@J1B|ry*n^P^$oH6|yjc1;{c628KiwQAGH|gaIw&zTyA? literal 0 HcmV?d00001 diff --git a/rsa-algorithms/src/main.c b/rsa-algorithms/src/main.c new file mode 100644 index 0000000..86d0112 --- /dev/null +++ b/rsa-algorithms/src/main.c @@ -0,0 +1,33 @@ +#include "rsa.h" +#include + +int main() { + unsigned long e, d, n; + + // Generate public and private keys + rsa_generate_keys(&e, &d, &n); + printf("Public Key: (e = %lu, n = %lu)\n", e, n); + printf("Private Key: (d = %lu, n = %lu)\n", d, n); + + // Ask for a message to encrypt (assuming it's an integer for simplicity) + unsigned long message; + printf("Enter a message to encrypt (as an integer smaller than %lu): ", n); + scanf("%lu", &message); + + // Ensure message is smaller than n + if (message >= n) { + printf("Error: Message must be smaller than %lu.\n", n); + return 1; + } + + // Encrypt the message + unsigned long ciphertext = rsa_encrypt(message, e, n); + printf("Encrypted message: %lu\n", ciphertext); + + // Decrypt the message + unsigned long decrypted_message = rsa_decrypt(ciphertext, d, n); + printf("Decrypted message: %lu\n", decrypted_message); + + return 0; +} + diff --git a/rsa-algorithms/src/rsa.c b/rsa-algorithms/src/rsa.c new file mode 100644 index 0000000..6e58098 --- /dev/null +++ b/rsa-algorithms/src/rsa.c @@ -0,0 +1,81 @@ +#include "rsa.h" +#include +#include +#include + +// Helper function to calculate the greatest common divisor (GCD) +static unsigned long gcd(unsigned long a, unsigned long b) { + while (b != 0) { + unsigned long temp = b; + b = a % b; + a = temp; + } + return a; +} + +// Helper function to find the modular inverse using the extended Euclidean algorithm +static unsigned long mod_inverse(unsigned long e, unsigned long phi) { + long t = 0, newt = 1; + unsigned long r = phi, newr = e; + + while (newr != 0) { + unsigned long quotient = r / newr; + + // Update t and newt + long temp = t; + t = newt; + newt = temp - quotient * newt; + + // Update r and newr + unsigned long temp_r = r; + r = newr; + newr = temp_r - quotient * newr; + } + + if (r > 1) return 0; // e is not invertible + if (t < 0) t += phi; // Ensure t is positive + + return (unsigned long)t; +} + + +// Generate RSA keys (public and private) +void rsa_generate_keys(unsigned long *e, unsigned long *d, unsigned long *n) { + // Two prime numbers (for simplicity, using small values) + unsigned long p = 61, q = 53; + *n = p * q; + unsigned long phi = (p - 1) * (q - 1); + + // Choose e such that 1 < e < phi(n) and gcd(e, phi(n)) = 1 + *e = 17; // Commonly chosen small prime number + if (gcd(*e, phi) != 1) { + printf("Error: e and phi(n) are not coprime.\n"); + exit(1); + } + + // Calculate d, the modular inverse of e mod phi(n) + *d = mod_inverse(*e, phi); + if (*d == 0) { + printf("Error: Could not find modular inverse of e.\n"); + exit(1); + } +} + +// Encrypt message using public key (e, n) +unsigned long rsa_encrypt(unsigned long message, unsigned long e, unsigned long n) { + unsigned long result = 1; + for (unsigned long i = 0; i < e; i++) { + result = (result * message) % n; + } + return result; +} + +// Decrypt ciphertext using private key (d, n) +unsigned long rsa_decrypt(unsigned long ciphertext, unsigned long d, unsigned long n) { + unsigned long result = 1; + for (unsigned long i = 0; i < d; i++) { + result = (result * ciphertext) % n; + } + return result; +} +