พรีไวส์ สําหรับ การ สร้าง โปรโตคอล สื่อสาร ที่ ปลอด ภัย ใน ซี

ก่อนการดําน้ําไปยังโปรแกรม OfficeSSL โดยแน่ใจว่าสภาพแวดล้อมการพัฒนาของคุณ รวมถึงตัวคอมโพเนนท์ CCCS (CLC หรือ CLanger) มีความรู้พื้นฐานในการเขียนโปรแกรมแบบซ็อกเก็ต และไลบรารี OpenSSL ได้ติดตั้งเอาไว้ OpenSSL ให้ใช้กระบวนการอย่างรัดกุมของอัลกอริทึมในการใช้งานอัลกอริทึมของการเข้ารหัสแบบ OpenSSL ทําให้เป็นตัวเลือกมาตรฐานสําหรับการสื่อสารแบบปลอดภัยใน C. บนเครื่องลินุกซ์, ติดตั้ง OpenSSL ผ่านระบบจัดการแพกเกจของคุณ (FLT: 0). ออน Februs, enterbaries หรือสร้างจากแหล่งกําเนิด enter. enterfircity. access/ Proffecterf. serverververververworder (e.

การ เข้าใจ อาคาร ไคร พ์ กราฟฟิก

โพรโทคอลการสื่อสารแบบปลอดภัย จะอยู่บน 3 หลัก: ความลับ, ความซื่อสัตย์, และการตรวจสอบสิทธิ์ ความปลอดภัยจะประสบความสําเร็จโดยการเข้ารหัส, การตรวจสอบว่าเฉพาะผู้รับที่ตั้งใจสามารถอ่านจดหมายได้เท่านั้น ความซื่อสัตย์จะแน่ใจว่า ข้อมูลจะไม่ถูกเปลี่ยนแปลงในการรับส่งข้อมูล การตรวจสอบสิทธิ์จะยืนยันการแสดงตัวของพรรคการสื่อสารได้ ตามลําดับที่คุณมักผนวกการเข้ารหัสเข้าด้วยกัน, การเข้ารหัสด้วยรหัสผ่าน (HMC) และกลไกการแลกเปลี่ยนกุญแจ เช่น Diffie-houghman

การเข้ารหัสแบบสมมาตรกับ AES

มาตรฐานการเข้ารหัสขั้นสูง (AES) เป็นการเข้ารหัสแบบสมมาตรที่แพร่หลายมากที่สุด โดยมันทํางานบนบล็อกขนาด 128 บิต และรองรับคีย์ขนาด 128, 192 หรือ 256 บิต สําหรับการสื่อสารแบบปลอดภัย เช่น เอซีส์ในโหมด Galois/ Fervice (GCM) ซึ่งให้ทั้งความลับและความซื่อสัตย์ในปฏิบัติการเดียว OpenSVP เชื่อมต่อข้อมูลและเข้ารหัสโดยใช้ AESGCM โหมดหลีกเลี่ยงการใช้ ECBC รุ่นเก่า เช่น ECBC หรือแบบรวมเข้ากับระบบตรวจสอบและตรวจสอบสิทธิ์

แลกเปลี่ยนคีย์กับดิฟฟี่ - ฮอฟแมน

เพื่อความมั่นในการตกลงในความลับร่วมกันผ่านช่องทางที่ไม่ปลอดภัย ให้ใช้ Diffie - Howman (DH) แลกเปลี่ยนกุญแจส่วนตัว และแลกเปลี่ยนตัวแปรสาธารณะด้วย โดยจะคํานวณความลับทั่วไป [FLT: 0] – Howman มีความเสี่ยงในการจู่โจมแบบไร้ความปราณีหากยังไม่มีการตรวจสอบสิทธิ์ ดังนั้นคุณอาจขยายเรื่องนี้ด้วยลายเซ็นหรือการใช้กุญแจก่อนการผลิตได้ สําหรับพิจารณาใช้ eprefilf-DOffman (DHOFFFFFL) เพื่อให้มีการปกปิดข้อมูลอย่างสมบูรณ์แบบ

ความ ซื่อ สัตย์ มั่นคง และ การ พิสูจน์ ด้วย การ ใช้ HMAC

เพื่อตรวจสอบว่าข้อความไม่ได้ถูกแก้ไขเพิ่มเติมด้วย build ของ HAHC ที่รับข้อมูล และเปรียบเทียบมันกับค่าที่ส่งมา ขั้นตอนนี้ป้องกันการเล่นและแก้ไขข้อผิดพลาดได้ ACLAM จะใช้ฟังก์ชัน SOCKS และการเข้ารหัสแบบเข้ารหัสแบบเข้ารหัส (เช่น Shaahzh256) ซึ่งทําหน้าที่แทน โพรโทคอลเดียวกันนี้ยังเป็นรูปแบบที่ง่ายต่อการใช้งานในการใช้งานในการใช้งานมาตรฐาน

ตั้งค่า OpenSSL ในโครงการของคุณ C

OpenSSL ต้องการการเริ่มระบบอย่างระวัง รวมหัวจดหมาย [FLT: 1] และ ที่จุดเริ่มต้นโปรแกรมของคุณ สําหรับการจัดการข้อผิดพลาด ให้ใช้ [FT: 3] และ[FLT: 4] เมื่อเชื่อมโยงให้เพิ่ม [FLT: 5] เข้ากับธงตัวร่วมของคุณ A. ขนาดเล็กที่สุดมีลักษณะเช่นนี้:

#include <openssl/evp.h>
#include <openssl/rand.h>
#include <openssl/err.h>
// Initialize OpenSSL
void init_openssl() {
 SSL_load_error_strings();
 OpenSSL_add_all_algorithms();
}

การ สร้าง ชั้น ของ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ ด้วย เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ เคลือบ ด้วย แว่น

การขนส่งพื้นฐานสําหรับโพรโทคอลของคุณ คือ TCP ซึ่งให้คําสั่งที่เชื่อถือได้ สร้างแม่ข่ายที่รับฟังการเชื่อมต่อที่เข้ามา และไคลเอนต์ที่เริ่มการจับมือ ใช้ฐานของ POSIX กับ [FT: 7] [FLT: 8], [FLT: 9], [FLT: 10] ทางฝั่งเซิร์ฟเวอร์, และ[FLT: 11] [FT] [FT]] [FT]]]]] ด้านข้างของไคลเอนต์ login: [FTH]. logy to tabout the language.

ตัวอย่างเซิร์ฟเวอร์ Skleton

int server_fd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in address;
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(8080);
bind(server_fd, (struct sockaddr*)&address, sizeof(address));
listen(server_fd, 3);
int client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &addr_len);

โปรแกรมลูกข่าย Skleton

int sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(8080);
inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);
connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr));

แลกเปลี่ยนกุญแจของดิฟฟี่-ฮอจแมน

หลังจากสร้างการเชื่อมต่อ TCP แล้ว โปรแกรมและเซิร์ฟเวอร์ จะทําการแลกเปลี่ยนคีย์ DH แต่ละด้านสร้างคู่คีย์ DH โดยใช้ OpenSSL [FLT: 15] API กุญแจสาธารณะจะถูกส่งผ่านซ็อกเก็ต และทั้งสองฝั่งจะได้ความลับร่วมกันโดยใช้ [FLT: 16] สําหรับความเรียบง่าย ใช้กลุ่มหลักคงที่ (เช่น [FTT: 17] โดยมีตัวแปรจาก [FLT] เป็นตัวแปร [FLT: 18] ในโพรโทคอลจริง ๆ คุณจะใช้ continuation หรือ config config config configor.

// Generate DH parameters
EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_DH, NULL);
EVP_PKEY_paramgen_init(pctx);
EVP_PKEY_CTX_set_dh_paramgen_prime_len(pctx, 2048);
EVP_PKEY *params = NULL;
EVP_PKEY_paramgen(pctx, &params);

// Generate key pair
EVP_PKEY_CTX *kctx = EVP_PKEY_CTX_new(params, NULL);
EVP_PKEY_keygen_init(kctx);
EVP_PKEY *my_key = NULL;
EVP_PKEY_keygen(kctx, &my_key);

// Export public key to send
unsigned char *pub_key_der = NULL;
int pub_len = i2d_PUBKEY(my_key, &pub_key_der);
send(sock, pub_key_der, pub_len, 0);

2557) เมื่อวันที่ได้รับข้อมูลจากเพื่อนนําเข้ากุญแจสาธารณะโดยใช้ จากนั้นจึงค้นพบความลับที่ใช้ร่วมกัน ความลับที่ได้มาสามารถถูกเคลือบด้วยไม้ไ

เข้ารหัสและถอดรหัสจดหมายด้วย AESCM

AESCM เป็นโหมดที่ต้องการใช้ เพราะมีการให้ทั้งการเข้ารหัสและแท็กตรวจสอบในหนึ่งปฏิบัติการ ใช้ OpenSSL [FLT: 22] พร้อม [FLT: 22] โดยคุณต้องการเครื่องหมาย 12/2 (IF) และ Vichit ที่ได้จากข้อมูล DH การเข้ารหัส ซึ่งได้จากการแบ่งปันข้อมูลลับมา การเข้ารหัสจะถูกผลิตในรูปแบบย่อย และภายหลังมีการเรียกข้อมูลข้อมูลเพิ่มเติมในอัลบั้ม 16 สืบค้นเมื่อ 16 ⁇ Bby, ไม่ใช้การเข้ารหัส และทําแท็กพร้อมกัน (FLT: 23) และถอดรหัสข้อมูลต่าง ๆ ได้ล้มเหลว หากข้อความถูกปฏิเสธ ถูกปฏิเสธ ป้ายกํากับจะถูกปฏิเสธ

// Encryption
EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
EVP_EncryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, key, nonce);
unsigned char ciphertext[1024];
int outlen;
EVP_EncryptUpdate(ctx, ciphertext, &outlen, plaintext, len);
int tmplen;
EVP_EncryptFinal_ex(ctx, ciphertext + outlen, &tmplen);
unsigned char tag[16];
EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, 16, tag);

เพิ่มความซื่อสัตย์กับ HMAC (หรือ leverrating GCM แท็ก)

หากคุณเลือกที่จะไม่ใช้ AESCM คุณสามารถเข้ารหัสร่วมกับ AESCBC จากนั้นคํานวณ HMAC ลงบนรหัสรหัสได้ ใช้ จาก OpenSSL กับ SHEX256. เพิ่มข้อมูล HMAC หลังจากการเข้ารหัส. ตัวรับข้อมูลข้อมูลและเปรียบเทียบ วิธีนี้ต้องใช้กุญแจสองดอกสําหรับการเข้ารหัส, หนึ่งสําหรับ HMAC. Devive จากทั้ง 2 แบบใช้ฟังก์ชันแบบใช้คีย์ Device (KFSFS) อย่างไรก็ตาม AGMFSCFS ก็ต้องการกําจัดความซับซ้อนและความซับซ้อน และลดความบกพร่องที่อาจจะเกิดขึ้นได้

การ นํา มา เชื่อม โยง กัน: การ ไหล เวียน ของ งาน

  1. ตั้งค่าการเชื่อมต่อ TCP ระหว่างไคลเอนต์และเซิร์ฟเวอร์
  2. ทั้ง 2 ฝ่ายสร้างคู่กุญแจเอฟีเมอร์เรนอล ดิฟฟิคแมน
  3. แลกกุญแจสาธารณะและคํานวณความลับร่วมกัน
  4. Deserive a 256hbit AES คีย์ และคีย์ HMC บิต (หรือใช้กุญแจตัวเดียวกันกับ GCM).
  5. ลูกค้าส่งคํานาม (12 ไบต์ สุ่ม) จากนั้น AESCM ที่เข้ารหัสไว้ จะส่งข้อความและแท็ก เพิ่มเซิร์ฟเวอร์ถอดรหัสและตรวจสอบ
  6. เซิร์ฟเวอร์ส่งการตอบสนองโดยใช้ Noncs ใหม่ (ไม่เคยใช้ค่าอะไรจากกุญแจเดียวกัน)
  7. ทั้งสองฝ่ายสามารถแลกเปลี่ยนข้อความได้ต่อไป สําหรับช่วงเวลาที่ยาวนานนั้น ในทางกลับกันให้ใช้ตัวช่วยแบบ DH แบบเดียวกัน หรือกลไกการจับหนู

การ ปฏิบัติ อย่าง ดี ที่ สุด ใน เรื่อง ความ ปลอด ภัย

ทดสอบโพรโทคอล

ทดสอบการประมวลผลของคุณโดยเรียกโปรแกรมโปรแกรมและเซิร์ฟเวอร์มาใช้งานบนเครื่องเดียวกัน (เครื่องคอมพิวเตอร์ภายใน) และตรวจสอบว่าจดหมายดังกล่าวถอดรหัสผิดหรือไม่ การแนะนําข้อผิดพลาดเช่น การแก้ไขรหัสหรือค่าเท็จเพื่อให้ตรวจสอบว่าโพรโทคอลนี้ปฏิเสธการใช้งานหรือไม่ ใช้เครื่องมือเช่นไวล์ชาร์ก เพื่อตรวจสอบการจราจรเครือข่ายดิบ และยืนยันด้วยว่าไม่สามารถตรวจสอบข้อความธรรมดาได้ สําหรับหน่วยการทดสอบ จะทําการจําลองพื้นผิวและการทดสอบรูปแบบดั้งเดิมแบบ OpenSSL ของ [FLT: 29] จะสามารถตรวจสอบค่าการแสดงผลของเครือข่ายที่เข้ากันได้

รูปแบบการวน

การสร้างระเบียบการสื่อสารที่ปลอดภัยใน C เป็นการฝึกการเรียนรู้ที่เยี่ยมยอด แต่ต้องระมัดระวังในการดูรายละเอียด การจํากัดการใช้งาน OpenSSL ที่ได้รับการรับรองแล้วว่ามีการใช้ OpenSSL สําหรับโครงการใด ๆ ที่เกินความคาดหมายของการเรียนรู้ เช่น AESCM และ HTL (0.1) และระบบ HTL (3. ) ซึ่งมีการตรวจสอบอย่างรัดกุม และใช้กระบวนการสื่อสารอย่างรัดกุม เข้มงวด เป็นไปตามความเชี่ยวชาญของการปรับปรุงระบบ และการปรับปรุงระบบของคุณ