วิธีรับ pem จาก crt. วิธีออกใบรับรอง SSL ที่ลงนามด้วยตนเองและทำให้เบราว์เซอร์ของคุณเชื่อถือได้ การสร้างคีย์ส่วนตัวและคำขอลงนาม

หลังจากซื้อใบรับรองแล้ว คุณสามารถดาวน์โหลดได้ใน " บริการทั่วไป" หากคุณกำลังติดตั้งใบรับรองบนเซิร์ฟเวอร์ของคุณ ให้ใช้ตัวอย่างการติดตั้งที่แสดงไว้ที่นี่

การติดตั้งบนโฮสติ้ง .masterhost

หากคุณต้องการติดตั้งใบรับรองบนโดเมนที่โฮสต์อยู่บนเรา โฮสติ้งเสมือนจากนั้นสามารถทำได้สองวิธี:

• SNI (ฟรี):
  แผนผังบริการ - โดเมน - รองรับ SSL - เพิ่ม
• IP เฉพาะ (140 รูเบิลต่อเดือน โดยปกติจะต้องทำงานกับระบบการชำระเงินบางระบบ):
  แผนผังบริการ - โดเมน - IP\SSL เฉพาะ - เพิ่มเลือกใบรับรองจากเมนูแบบเลื่อนลง

* หากต้องการอัปเดตใบรับรอง เช่น หลังจากต่ออายุ ให้ทำตามขั้นตอนที่คล้ายกัน: แผนผังบริการ - โดเมน - รองรับ SSL หรือ IP\SSL เฉพาะ(ขึ้นอยู่กับวิธีการติดตั้ง) - เปลี่ยนแปลง

การสร้าง (รวม) ใบรับรองสำหรับซอฟต์แวร์ Windows

หากต้องการติดตั้งใบรับรองผลลัพธ์บนซอฟต์แวร์ใดๆ ใน Windows ไฟล์ใบรับรองจะต้องมีทั้งใบรับรองและคีย์ส่วนตัว เหล่านั้น. คุณจะต้องรวมใบรับรองที่คุณได้รับจากเราเข้ากับไฟล์คีย์ส่วนตัวของคุณ

คุณสามารถทำได้เช่นนี้:

openssl pkcs12 - ส่งออก - ออกใบรับรอง pfx -inkey privateKey.key - ในใบรับรอง crt

Certificate.pfx - ชื่อของใบรับรองที่คุณจะได้รับจากการควบรวมกิจการ

privateKey.key - คีย์ส่วนตัว

Certificate.crt - ใบรับรองที่เราออกให้คุณ

ปาเช่

• คัดลอกไฟล์ ใบรับรอง SSLและไปยังเซิร์ฟเวอร์ของคุณ
• ถัดไปคุณจะต้องค้นหาไฟล์การกำหนดค่า Apache ที่จะแก้ไข

  โดยส่วนใหญ่ ไฟล์การกำหนดค่าดังกล่าวจะถูกจัดเก็บไว้ใน /etc/httpd ในกรณีส่วนใหญ่ ไฟล์การกำหนดค่าหลักจะเรียกว่า httpd.conf แต่ในบางกรณีก็บล็อก อาจอยู่ที่ด้านล่างของไฟล์ httpd.conf บางครั้งคุณจะพบบล็อกเช่น แยกกันภายใต้ไดเร็กทอรี เช่น /etc/httpd/vhosts.d/ หรือ /etc/httpd/sites/ หรือในไฟล์ชื่อ ssl.conf

  ก่อนเปิดไฟล์ใน โปรแกรมแก้ไขข้อความคุณต้องตรวจสอบให้แน่ใจว่ามีบล็อกอยู่ ซึ่งมีการตั้งค่า Apache

• ถัดไป ติดตั้งบล็อก SSL เพื่อตั้งค่าคอนฟิก

  หากคุณต้องการให้ไซต์ของคุณทำงานกับทั้งการเชื่อมต่อที่ปลอดภัยและไม่ปลอดภัย คุณต้องมีโฮสต์เสมือนสำหรับการเชื่อมต่อแต่ละรายการ เมื่อต้องการทำเช่นนี้ คุณควรทำสำเนาของที่มีอยู่ที่ไม่มีการป้องกัน โฮสต์เสมือนและสร้างมันขึ้นมาสำหรับการเชื่อมต่อ SSL ตามที่อธิบายไว้ด้านล่างในย่อหน้าที่ 4

• จากนั้นสร้างบล็อก เพื่อเชื่อมต่อการเชื่อมต่อ SSL

  ด้านล่างนี้เป็นตัวอย่างง่ายๆ ของโฮสต์เสมือนสำหรับการเชื่อมต่อ SSL ใน การกำหนดค่า SSLต้องเพิ่มส่วนที่เน้นด้วยตัวหนา:

  DocumentRoot /var/www/html2 ServerName www.yourdomain.com SSLEngine บน SSLCertificateFile /path/to/your_domain_name.crt SSLCertificateKeyFile /path/to/your_private.key SSLCertificateChainFile /path/to/root.crt แก้ไขชื่อไฟล์ให้ตรงกับไฟล์ใบรับรอง:
  • SSLCertificateFile - ไฟล์ใบรับรองของคุณ (เช่น your_domain_name.crt)
  • SSLCertificateKeyFile - ไฟล์คีย์ที่สร้างขึ้นเมื่อสร้าง CSR
  • SSLCertificateChainFile - ไฟล์ ใบรับรองหลัก.
• ตรวจสอบการกำหนดค่า Apache ของคุณก่อนรีสตาร์ท วิธีที่ดีที่สุดคือตรวจสอบไฟล์การกำหนดค่า Apache เพื่อหาข้อผิดพลาดก่อนรีสตาร์ท เนื่องจาก Apache จะไม่เริ่มทำงานอีกครั้งหากมีไฟล์การกำหนดค่าอยู่ ข้อผิดพลาดทางไวยากรณ์- เมื่อต้องการทำเช่นนี้ ให้ใช้คำสั่งต่อไปนี้: apachectl configtest
• ตอนนี้คุณสามารถรีสตาร์ท Apache ได้แล้ว

กินซ์

• คัดลอกไฟล์ใบรับรองไปยังเซิร์ฟเวอร์

  คัดลอกใบรับรองของคุณ (your_domain_name.crt) และใบรับรองหลัก (root.crt) พร้อมด้วยไฟล์ .key ที่คุณสร้างขึ้นเมื่อสร้างคำขอ CSR ไปยังไดเร็กทอรีบนเซิร์ฟเวอร์ของคุณที่คุณจะติดตั้งใบรับรอง เพื่อความปลอดภัย ให้บันทึกไฟล์เป็นแบบอ่านอย่างเดียว

• เชื่อมต่อใบรับรองกับใบรับรองหลัก

  คุณต้องรวมไฟล์ใบรับรองกับไฟล์ใบรับรองหลักเป็นไฟล์ .pem ไฟล์เดียวโดยการรันคำสั่งต่อไปนี้:

  cat root.crt >> your_domain_name.crt
• เปลี่ยนไฟล์โฮสต์เสมือน Nginx

  เปิดไฟล์โฮสต์เสมือน Nginx ของคุณสำหรับไซต์ที่คุณกำลังปกป้อง หากคุณต้องการให้ไซต์ทำงานกับทั้งการเชื่อมต่อที่ปลอดภัย (https) และการเชื่อมต่อที่ไม่ปลอดภัย (http) คุณต้องมีโมดูลเซิร์ฟเวอร์สำหรับการเชื่อมต่อแต่ละประเภท ทำสำเนาของโมดูลเซิร์ฟเวอร์ที่มีอยู่สำหรับ การเชื่อมต่อที่ไม่ปลอดภัยแล้วแปะไว้ด้านล่างของต้นฉบับ หลังจากนั้นให้เพิ่มบรรทัดด้านล่าง ตัวหนา:

  เซิร์ฟเวอร์ ( ฟัง 443; เปิด ssl; ssl_certificate /etc/ssl/your_domain_name.crt; (หรือ .pem) ssl_certificate_key /etc/ssl/your_domain_name.key; server_name your.domain.com; access_log /var/log/nginx/nginx. vhost.access.log; error_log /var/log/nginx/nginx.vhost.error.log; ตำแหน่ง / ( รูท /home/www/public_html/your.domain.com/public/; index index.html; )การตั้งชื่อไฟล์:
  • ssl_certificate - ไฟล์ที่มีใบรับรองหลักและใบรับรองหลัก (ขั้นตอนที่ 2)
  • ssl_certificate_key - ไฟล์ที่มีคีย์ที่สร้างขึ้นเมื่อสร้าง CSR
• รีสตาร์ท Nginx

  ป้อนคำสั่งต่อไปนี้เพื่อรีสตาร์ท Nginx:

  sudo /etc/init.d/nginx รีสตาร์ท

เอ็กซ์เชนจ์ 2010

• คัดลอกใบรับรองของคุณไปยังเซิร์ฟเวอร์ Exchange
• จากนั้นเปิด Exchange Management Console ด้วยวิธีนี้: Start > Programs > ไมโครซอฟต์เอ็กซ์เชนจ์ 2010 > คอนโซลการจัดการการแลกเปลี่ยน
• ตอนนี้คลิก "จัดการฐานข้อมูล" จากนั้นคลิก "การกำหนดค่าเซิร์ฟเวอร์"
• ถัดไป เลือกใบรับรอง SSL ของคุณจากเมนูตรงกลางหน้าต่าง จากนั้นคลิกที่ "ดำเนินการคำขอที่รอดำเนินการให้เสร็จสิ้น" ในเมนู "การดำเนินการ"
• เปิดไฟล์ใบรับรองของคุณ จากนั้นคลิกเปิด > เสร็จสิ้น

  Exchange 2010 มักจะแสดงข้อความแสดงข้อผิดพลาดที่ขึ้นต้นด้วยวลี "ข้อมูลต้นฉบับเสียหายหรือเข้ารหัส Base64 ไม่ถูกต้อง" ละเว้นข้อผิดพลาดนี้

• จากนั้น กลับไปที่ Exchange Management Console แล้วคลิก "กำหนดบริการให้กับใบรับรอง" เพื่อเริ่มใช้ใบรับรอง
• เลือกเซิร์ฟเวอร์ของคุณจากรายการคลิก "ถัดไป"
• ตอนนี้เลือกบริการที่ควรได้รับการปกป้องโดยใบรับรองแล้วคลิกถัดไป > กำหนด > เสร็จสิ้น ใบรับรองของคุณได้รับการติดตั้งแล้วและพร้อมใช้งานบน Exchange

ทุกวันนี้มันเป็นเรื่องธรรมดามากที่จะปรับปรุงความปลอดภัย เชื่อมต่อเครือข่ายหรือใช้ใบรับรอง SSL ในการตรวจสอบสิทธิ์ หนึ่งในความนิยมมากที่สุด ซอฟต์แวร์ฟรีสำหรับการสร้างใบรับรองคือ OpenSSL นี่คือยูทิลิตี้ บรรทัดคำสั่งซึ่งช่วยให้คุณสร้างได้ ประเภทต่างๆใบรับรอง เช่น PKI หรือ HTTPS

ในบทความนี้ เราจะดูว่าใบรับรองคืออะไร และคืออะไร และเราจะวิเคราะห์รายละเอียดการสร้างใบรับรอง OpenSSL นอกจากนี้ เราจะพิจารณาแต่ละขั้นตอนเพื่อให้คุณเข้าใจได้ง่ายขึ้นว่าเกิดอะไรขึ้นและอย่างไร

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

หากคุณสามารถถอดรหัสข้อความที่ส่งซึ่งเข้ารหัสโดยใช้กุญแจสาธารณะของคุณได้ นั่นก็คือคุณ คีย์ใช้งานได้เป็นคู่เท่านั้น และคุณจะไม่สามารถถอดรหัสสิ่งใดด้วยคีย์อื่นได้ แต่ยังเหลืออีกจุดหนึ่ง คุณจะทราบได้อย่างไรว่าคีย์สาธารณะนี้เป็นของคุณ เช่น เป็นของโดเมนของคุณ ง่ายมาก เพียงคุณต้องการใครสักคนจากแหล่งที่มีชื่อเสียง เช่น Comodo หรือ LetsEncrypt เพื่อเซ็นชื่อคีย์ของคุณ สิ่งเหล่านี้เรียกว่าหน่วยงานออกใบรับรอง

ในบทช่วยสอนนี้ เราจะจัดการกับคีย์ประเภทเหล่านี้:

• .pem, .crt, .cer- ใบรับรองสำเร็จรูปที่ลงนามโดยหน่วยงานออกใบรับรอง ส่วนขยายจะต่างกัน แต่มีความหมายเหมือนกัน พูดง่ายๆ ก็คือ ใบรับรองคือกุญแจสาธารณะที่มีการลงนาม พร้อมด้วยข้อมูลเล็กๆ น้อยๆ เกี่ยวกับบริษัทของคุณ
• .สำคัญ- คีย์ส่วนตัวหรือสาธารณะ
• .ซีเอสอาร์- คำขอลงนามใบรับรอง ไฟล์นี้จะจัดเก็บคีย์สาธารณะของคุณพร้อมข้อมูลเกี่ยวกับบริษัทและโดเมนที่คุณระบุ

ตอนนี้เรามาดูวิธีสร้างใบรับรอง openssl วิธีลงนามและสิ่งที่ต้องทำเพื่อสิ่งนี้ รุ่น ปุ่ม openssl- สวยจังเลย งานง่ายๆถ้าคุณคิดออกทั้งหมด

การสร้างคีย์ส่วนตัวและคำขอลงนาม

คุณไม่จำเป็นต้องลงนามใบรับรองกับ CA คุณสามารถลงนามด้วยตนเองได้ แต่จะต้องทำเพิ่มเติมในภายหลัง คุณจะต้องผ่านกระบวนการทั้งหมดต่อไป ขั้นแรก มาดูวิธีการสร้างคีย์ส่วนตัวตั้งแต่เริ่มต้น และระบุ ข้อมูลที่จำเป็น- นี่คือ CN ที่ควรระบุของคุณ ชื่อโดเมนที่คุณจะใช้ใบรับรอง คุณสามารถระบุได้เช่นกัน ข้อมูลเพิ่มเติมเกี่ยวกับบริษัท ที่อยู่ และองค์กรของคุณ แต่ไม่จำเป็นอีกต่อไป

หากต้องการสร้างคีย์ส่วนตัวและคำขอลงนามคีย์สาธารณะ ให้รันคำสั่งต่อไปนี้:

openssl req -newkey rsa:2048 -nodes -keyout domain.key -out โดเมน.csr

ตัวเลือก -newkey ระบุสิ่งที่จะสร้าง คู่ใหม่คีย์ และในพารามิเตอร์ เราระบุประเภท rsa และความซับซ้อน 2,048 ไบต์ ตัวเลือก -nodes ระบุว่าคุณไม่จำเป็นต้องเข้ารหัสคีย์ ส่วนตัวเลือก -new ระบุว่าคุณจำเป็นต้องสร้างคำขอ csr หากคุณมีคีย์ส่วนตัวอยู่แล้ว คุณสามารถสร้างคำขอ csr ได้โดยใช้คำสั่งต่อไปนี้:

openssl req -key domain.key - ใหม่ -out domain.csr

ในระหว่างการสร้าง คุณจะต้องให้ข้อมูลที่จำเป็นทั้งหมดสำหรับ Csr ซึ่งส่วนใหญ่เป็นโดเมนและองค์กร คุณสามารถสร้างคีย์ส่วนตัวแยกกันได้:

openssl genrsa -des3 - ออก domain.key 2048

นอกจากนี้ คุณสามารถสร้างคำขอ CSR จากใบรับรองและคีย์ส่วนตัวที่มีอยู่แล้วได้ จากนั้นคุณไม่จำเป็นต้องป้อนข้อมูล แต่จะได้รับจากใบรับรอง:

openssl x509 - ในโดเมน.crt -signkey domain.key -x509toreq - ออกโดเมน.csr

ตัวเลือก -x509toreq ระบุว่าต้องใช้ใบรับรองสำหรับ X509 เพื่อขอรับ CSR X509 เป็นใบรับรองที่ลงนามด้วยตนเอง โดยปกติใบรับรองจะลงนามโดยใบรับรองอื่น แต่ใบรับรองนี้ลงนามโดยตัวมันเอง หากคุณได้รับใบรับรองจาก CA ก็ไม่จำเป็นต้องใช้พารามิเตอร์นี้

การลงนามใบรับรอง OpenSSL

สมมติว่าคุณมีคีย์ส่วนตัวและคำขอลายเซ็นซึ่งจริงๆ แล้วเป็นคีย์สาธารณะ ตอนนี้คุณต้องลงชื่อเพื่อรับใบรับรองที่ใช้งานได้ มีหลายตัวเลือกที่นี่ คุณสามารถส่งไฟล์ CSR เพื่อขอลายเซ็นไปยังหน่วยงานออกใบรับรอง เช่น LetsEncrypt คุณสามารถลงนามใบรับรองด้วยคีย์เดียวกันกับที่ใช้สร้างขึ้นได้ และตัวเลือกที่สามคือการสร้างผู้ออกใบรับรองของคุณเอง

ฉันจะไม่พิจารณาวิธีแรก ทุกอย่างเรียบง่ายที่นี่ ใช้ยูทิลิตี้บริการหรือกรอกแบบฟอร์มบนเว็บและรับใบรับรองสำเร็จรูป ตัวเลือกที่สองน่าสนใจกว่ามาก เราจะลงนามใบรับรองของเราเองโดยใช้รหัสที่สร้างขึ้น:

openssl x509 -signkey โดเมน.คีย์ -ในโดเมน.csr -req -วัน 365 -ออกโดเมน.crt

เมื่อใช้พารามิเตอร์ -days เราระบุว่าใบรับรองจะมีอายุการใช้งาน 365 วัน นั่นคือเป็นเวลาหนึ่งปี คุณสามารถรวมทุกอย่างเป็นคำสั่งเดียวและสร้างคีย์ส่วนตัว, Csr และใบรับรองที่ลงนามได้ในคราวเดียว:

openssl req -newkey rsa:2048 -nodes -keyout domain.key
-x509 -วัน 365 -ออกโดเมน.crt

หรือสร้างใบรับรอง openssl ที่ลงนามด้วยตนเองจากคีย์ส่วนตัวที่มีอยู่โดยไม่มี csr:

openssl req -key domain.key - ใหม่ -x509 - วัน 365 - ออก domain.crt

ตัวเลือก -new บอกว่าจะขอข้อมูล Csr จากผู้ใช้ เพื่อให้เบราว์เซอร์เชื่อถือคีย์ คุณจะต้องนำเข้าใบรับรองเดียวกันลงในรายการที่เชื่อถือได้ ตอนนี้เรามาดูวิธีที่สามในการสร้างใบรับรอง OpenSSL - ลงนามโดยใช้ CA ของคุณเองซึ่งเป็นผู้ออกใบรับรอง

ตอนนี้คุณคิดว่านี่เป็นสิ่งที่ซับซ้อนใช่ไหม? แต่ไม่ นี่เป็นโฟลเดอร์ปกติที่มีคีย์ส่วนตัวที่ป้องกันด้วยรหัสผ่าน ซึ่งเราจะเซ็นชื่อคีย์อื่นๆ ทั้งหมดด้วย ก เปิดคู่ต้องเพิ่มคีย์นี้ในเบราว์เซอร์ทั้งหมดที่จะเชื่อถือ

โดยทั่วไปศูนย์รับรองในองค์กรขนาดใหญ่จะตั้งอยู่ที่ คอมพิวเตอร์แยกกันซึ่งไม่ได้เชื่อมต่อกับเครือข่ายด้วยซ้ำ แต่เช่นเราจะวางโฟลเดอร์ไว้ในของเรา ระบบไฟล์/ฯลฯ/:

openssl req -newkey rsa:4096 -x509 - ส่วนขยาย x509_ca -keyout /etc/ca/certs/ca.key -out /etc/ca/certs/ca.crt -days 3654

พารามิเตอร์ -extensions โหลดส่วนขยายที่จำเป็นเพื่อสร้างใบรับรอง CA เรากำหนดระยะเวลาการใช้งานที่ยาวนาน - สิบปี สิ่งที่เหลืออยู่คือการลงนามใบรับรองของเราที่สร้างขึ้นก่อนหน้านี้:

openssl ca -extensions x509_client -in ~/domain.csr -out ~/domain.crt

เสร็จสิ้น ใบรับรองของเราได้รับการลงนามแล้ว แต่ตอนนี้ เพื่อให้เบราว์เซอร์เชื่อถือได้ คุณต้องเพิ่มใบรับรอง CA ลงในรายการเบราว์เซอร์ที่เชื่อถือได้

ดูใบรับรอง

ใบรับรองจะถูกบันทึกในรูปแบบ pem ซึ่งหมายความว่าคุณจะไม่สามารถเปิดเป็นใบรับรองได้ ไฟล์ข้อความและจำเป็นต้องใช้ ทีมพิเศษเพื่อดูข้อมูลเกี่ยวกับพวกเขา ขั้นแรก ให้ดูที่เนื้อหาของ Csr:

openssl req -text -noout -verify -in domain.csr

เราดูเนื้อหาของใบรับรองในโหมดข้อความธรรมดา:

openssl x509 -ข้อความ -noout -in domain.crt

เราตรวจสอบว่าใบรับรองนั้นลงนามโดย CA ที่ต้องการจริงหรือไม่:

openssl ตรวจสอบ -verbose -CAfile ca.crt domain.crt

ดูรหัสส่วนตัว:

openssl rsa -เช็คอิน - ในโดเมน.คีย์

หากต้องการตรวจสอบว่าคีย์ส่วนตัว ใบรับรอง และคีย์สาธารณะเกี่ยวข้องกันหรือไม่ คุณสามารถคำนวณผลรวม md5 สำหรับคีย์เหล่านี้ได้ หากค่าตรงกัน แสดงว่าคีย์เหล่านี้มาจากคู่เดียวกัน:

openssl rsa -noout -โมดูลัส - ใน domain.key | openssl md5
$ openssl x509 -noout -modulus -in domain.crt | openssl md5
$ openssl req -noout -modulus -in domain.csr | openssl md5

มีสถานการณ์มากมายเมื่อคุณจำเป็นต้องเข้ารหัส ไฟล์เฉพาะหรือโฟลเดอร์ เช่น หากข้อมูลถูกส่งผ่านช่องทางเปิดหรือจัดเก็บไว้ สื่อภายนอก- หลายๆ คน (รวมถึงฉันด้วย) ใช้ truecrypt แต่จุดประสงค์หลักของโปรแกรมนี้คือการทำงานกับพาร์ติชั่นที่เข้ารหัส ดังนั้นจึงไม่ค่อยดีนักในกรณีนี้

OpenSSL ค่อนข้างเหมาะสำหรับงานดังกล่าว - โซลูชันข้ามแพลตฟอร์มที่เชื่อถือได้ รองรับ OpenSSL อัลกอริธึมต่างๆการเข้ารหัส อีกทั้งยังมีการติดตั้งเป็นค่าเริ่มต้นในหลาย ๆ ระบบปฏิบัติการและการติดตั้งส่วนที่เหลือก็ไม่ใช่เรื่องยาก

ด้านล่างนี้เป็นบทสรุปพื้นฐานของการใช้การเข้ารหัสแบบสมมาตรและไม่สมมาตรใน OpenSSL รวมถึงสคริปต์สองสามตัวที่ทำให้ง่ายขึ้น การเข้ารหัสแบบสมมาตรด้วยกุญแจแบบครั้งเดียว

วิธีที่ง่ายที่สุดในการปกป้องข้อมูลโดยใช้ OpenSSL คือการเข้ารหัสแบบสมมาตร คำสั่งต่อไปนี้เข้ารหัสและถอดรหัสไฟล์ document.zip โดยใช้ อัลกอริทึม AESด้วยความยาวคีย์ 256 บิต:

Openssl enc -aes-256-cbc -salt -in document.zip -out เอกสาร enc
openssl enc -d -aes-256-cbc -in document.enc -out document.zip

ปัญหาเกี่ยวกับคำสั่งเหล่านี้อาจเป็นเพราะต้องใช้รหัสผ่าน มีบางสถานการณ์ที่ไม่พึงประสงค์ ตัวอย่างเช่น การสำรองข้อมูล/การเข้ารหัสข้อมูลอัตโนมัติตามกำหนดเวลา หรือหากข้อมูลถูกเข้ารหัสโดยบุคคลหนึ่งและถูกถอดรหัสโดยบุคคลอื่น

ในกรณีเช่นนี้จึงมีการคิดค้นการเข้ารหัสคีย์สาธารณะ ใน กรณีทั่วไปคุณจะต้องสร้างรหัสสาธารณะและรหัสส่วนตัว คำสั่งแรกจะสร้างคีย์ส่วนตัว private.pem ส่วนคำสั่งที่สองจะสร้างคีย์สาธารณะ public.pem:

Opensl ประเภท -ออก private.pem -aes256 2048
openssl rsa -in private.pem -pubout -out public.pem

เป็นผลให้คุณได้รับคู่ คีย์อาร์เอสเอความยาว 2048 บิต น่าเสียดายที่ในระบบ RSA ขนาดของข้อมูลที่เข้ารหัสถูกจำกัดด้วยขนาดคีย์ ดังนั้นจึงไม่สามารถเข้ารหัสข้อมูลเกิน 2Kb ได้ มีวิธีแก้ไขปัญหานี้ - ข้อมูลจะถูกเข้ารหัสก่อน อัลกอริธึมแบบสมมาตร(คล้ายกับที่ใช้ด้านบน) โดยใช้คีย์ครั้งเดียว จากนั้นคีย์แบบครั้งเดียวนี้จะถูกเข้ารหัส กุญแจสาธารณะ- ในระหว่างการถอดรหัส คีย์แบบครั้งเดียวจะถูกถอดรหัสด้วยคีย์ส่วนตัว รายละเอียดเพิ่มเติมเกี่ยวกับเรื่องนี้ได้รับการเขียนไว้เป็นอย่างดีในบทความเกี่ยวกับHabré

สคริปต์ต่อไปนี้จะช่วยเข้ารหัสอัตโนมัติ เนื่องจากผลลัพธ์ที่คุณจะได้รับคีย์และข้อมูลแบบครั้งเดียว (encrypt.sh) ในรูปแบบที่เข้ารหัส:

ชื่อไฟล์="$1"
สาธารณะ = $2"
เซสชั่นคีย์="$3"
ผลลัพธ์="$4"

# สร้างคีย์สมมาตรแบบสุ่ม
พาสไซส์=30
ถ้า [ -c /dev/urandom ] ; แล้ว
KEY=`head -c 30 /dev/urandom | openssl enc -base64`
อื่น
KEY=`openssl แรนด์ -base64 30`
ฟิ
ส่งออกคีย์

# เข้ารหัสคีย์สมมาตรโดยใช้กุญแจสาธารณะ
openssl rsautl - เข้ารหัส -inkey "$ PUBLICKEY" - ออก "$ SESSIONKEY" -pubin<$คีย์
อีโอเอฟ

# เข้ารหัสไฟล์
openssl enc -aes-256-cbc -pass env:KEY -in "$FILENAME" - ออก "$RESULT"

คำสั่งต่อไปนี้ใช้พับลิกคีย์ public.pem เพื่อเข้ารหัสไฟล์ document.zip มันจะสร้าง session.key คีย์ที่เข้ารหัสเพียงครั้งเดียวและเอกสารข้อมูลที่เข้ารหัส.enc:

./encrypt.sh document.zip public.pem session.key เอกสาร enc

สคริปต์ถอดรหัส (decrypt.sh):

คีย์ส่วนตัว="$1"
เซสชั่นคีย์="$2"
เข้ารหัส="$3"
ถอดรหัสแล้ว="$4"

# ถอดรหัสคีย์สมมาตรโดยใช้คีย์ส่วนตัว
คีย์ =` openssl rsautl -decrypt -inkey "$PRIVATEKEY" -in "$SESSIONKEY" `
ส่งออกคีย์

# ถอดรหัสไฟล์
openssl enc -aes-256-cbc -d -pass env:KEY -in "$ENCRYPTED" -out "$DECRYPTED"

คำสั่งถอดรหัสจะใช้ไพรเวตคีย์ private.pem และคีย์ครั้งเดียว session.key เพื่อถอดรหัสไฟล์ document.enc มันจะสร้างไฟล์เอกสาร.zip:

./decrypt.sh private.pem session.key เอกสาร enc เอกสาร zip

อย่างที่คุณเห็นการเข้ารหัสด้วย กุญแจสาธารณะสามารถทำได้ง่ายพอๆ กับการสมมาตร แต่มีวิธีที่ง่ายกว่านั้นอีก ฉันได้รับแจ้งให้เขียนโพสต์นี้จากบล็อก SbF₅ ผู้เขียน (มีประสบการณ์ด้านการทุบตีมากกว่าฉันอย่างไม่ต้องสงสัย) เขียนสคริปต์ที่เก็บถาวรโฟลเดอร์ เข้ารหัสด้วยกุญแจสาธารณะ และสร้างสคริปต์อื่นที่มีทุกสิ่งที่จำเป็น: คีย์ครั้งเดียว ข้อมูล และคำสั่งจริงสำหรับการถอดรหัส นอกจากนี้ สคริปต์สามารถสร้างคู่คีย์ RSA ให้กับคุณได้:

./encrypt-file.sh -keys public.pem private.pem
./encrypt-file.sh โฟลเดอร์ public.pem > decrypt-folder.sh
chmod +x ถอดรหัสโฟลเดอร์.sh
./decrypt-folder.sh private.pem > folder.tar

ในตัวอย่างนี้ เราสร้างคู่คีย์ขึ้นมาก่อน หลังจากนั้น โฟลเดอร์โฟลเดอร์ถูกเข้ารหัสลงในสคริปต์ decrypt-folder.sh จากนั้นถอดรหัสลงในไฟล์เก็บถาวร folder.tar ข้อเสียที่เป็นไปได้ของวิธีนี้คือข้อมูลใน decrypt-folder.sh ถูกจัดเก็บในรูปแบบ BASE64 ดังนั้นขนาดจึงเพิ่มขึ้น

รปภย้ายไปที่บล็อกความปลอดภัยของข้อมูล

เว็บไซต์หลักๆ ทั้งหมดได้เปลี่ยนไปใช้มานานแล้ว https โปรโตคอล- แนวโน้มยังคงดำเนินต่อไป และลูกค้าของเราหลายรายต้องการให้เว็บไซต์ของตนทำงานผ่านโปรโตคอลที่ปลอดภัย และหากมีการพัฒนาแบ็กเอนด์เพื่อ แอปพลิเคชันมือถือจากนั้นจำเป็นต้องมี https ตัวอย่างเช่น Apple กำหนดให้เซิร์ฟเวอร์สื่อสารกับแอปพลิเคชันผ่าน โปรโตคอลที่ปลอดภัย- ข้อกำหนดนี้เริ่มนำมาใช้ตั้งแต่ปลายปี 2559

ในการผลิตไม่มีปัญหากับใบรับรอง โดยปกติแล้วผู้ให้บริการโฮสติ้งจะจัดเตรียมไว้ให้ ส่วนต่อประสานที่ใช้งานง่ายเพื่อเชื่อมต่อใบรับรอง การออกใบรับรองก็ไม่ใช่เรื่องยากเช่นกัน แต่ในขณะที่ทำงานในโครงการ นักพัฒนาแต่ละคนจะต้องดูแลใบรับรองด้วยตนเอง
ในบทความนี้ ฉันจะแสดงวิธีออกใบรับรอง SSL ที่ลงนามด้วยตนเองและทำให้เบราว์เซอร์เชื่อถือได้

เพื่อออกใบรับรองให้กับคุณ โดเมนท้องถิ่นคุณจะต้องมีใบรับรองหลัก ใบรับรองอื่น ๆ ทั้งหมดจะออกให้ตามหลักเกณฑ์ ใช่สำหรับทุกคน ด้านบนใหม่โดเมนระดับที่คุณต้องออกใบรับรองของคุณเอง การได้รับใบรับรองหลักนั้นค่อนข้างง่าย
ขั้นแรก เรามาสร้างคีย์ส่วนตัวกันก่อน:

Opensl genrsa - ออก rootCA.key 2048
จากนั้นใบรับรองนั้นเอง:

คำขอ Openssl -x509 - ใหม่ - โหนด - คีย์ rootCA.key -sha256 - วัน 1024 - ออก rootCA.pem
คุณจะต้องเข้า ประเทศ, เมือง, บริษัทฯลฯ เป็นผลให้เราได้รับไฟล์สองไฟล์: rootCA.keyและ rootCA.pem

มาดูสิ่งสำคัญกันดีกว่า การออกใบรับรองที่ลงนามด้วยตนเองเช่นเดียวกับรูท นี่คือสองคำสั่ง แต่คำสั่งจะมีพารามิเตอร์มากกว่ามาก และเราต้องการตัวช่วย ไฟล์การกำหนดค่า- งั้นเรามาใส่ทั้งหมดไว้ในรูปแบบกันดีกว่า สคริปต์ทุบตีก create_certificate_for_domain.sh

จำเป็นต้องมีพารามิเตอร์แรก เราจะแสดงคำแนะนำสั้นๆ สำหรับผู้ใช้

หาก [ -z "$1" ] ให้สะท้อน "โปรดระบุโดเมนย่อยเพื่อสร้างใบรับรองสำหรับ"; echo "เช่น mysite.localhost" ออก; ฟิ
มาสร้างคีย์ส่วนตัวใหม่หากไม่มีอยู่หรือใช้คีย์ที่มีอยู่:

ถ้า [ -f device.key ]; จากนั้น KEY_OPT="-key" else KEY_OPT="-keyout" fi
ลองถามผู้ใช้เกี่ยวกับชื่อโดเมน มาเพิ่มความสามารถในการระบุ "ชื่อสามัญ" (ใช้เมื่อสร้างใบรับรอง):

DOMAIN=$1 COMMON_NAME=$(2:-$1)
เพื่อหลีกเลี่ยงการตอบคำถาม โหมดโต้ตอบเราจะมาเรียงคำตอบกัน และกำหนดระยะเวลาที่มีผลบังคับใช้ของใบรับรอง:

SUBJECT="/C=CA/ST=None/L=NB/O=None/CN=$COMMON_NAME" NUM_OF_DAYS=999
ตัวแปร SUBJECT แสดงรายการคำถามเดียวกันทั้งหมดที่ถูกถามเมื่อสร้างใบรับรองหลัก ( ประเทศ, เมือง, บริษัทฯลฯ) ค่าทั้งหมดยกเว้น CN สามารถเปลี่ยนแปลงได้ตามดุลยพินิจของคุณ

เปิดในหน้าต่างใหม่ -newkey rsa:2048 -sha256 -nodes $KEY_OPT device.key -subj "$SUBJECT" -out device.csr
การสร้างไฟล์ใบรับรอง- สำหรับสิ่งนี้ เราจำเป็นต้องมีไฟล์เสริมพร้อมการตั้งค่า ในไฟล์นี้ เราจะเขียนโดเมนที่ใบรับรองและการตั้งค่าอื่นๆ บางอย่างจะใช้ได้ ลองโทรหาเขาสิ v3.ต่อ- โปรดทราบว่านี่เป็นไฟล์แยกต่างหากและไม่ใช่ส่วนหนึ่งของสคริปต์ทุบตี

AuthorityKeyIdentifier=keyid,ผู้ออก basicConstraints=CA:FALSE keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment subjectAltName = @alt_names DNS.1 = %%DOMAIN%% DNS.2 = *.%%DOMAIN%%
ใช่แล้ว ใบรับรองของเราจะใช้ได้กับโดเมนหลักและโดเมนย่อยทั้งหมด บันทึกบรรทัดข้างต้นลงในไฟล์ v3.ต่อ

กลับไปที่สคริปต์ทุบตีของเรา ซึ่งเป็นรากฐาน ไฟล์เสริม v3.ต่อสร้าง ไฟล์ชั่วคราวระบุโดเมนของเรา:

แมว v3.ext | sed s/%%DOMAIN%%/$COMMON_NAME/g > /tmp/__v3.ext
เราออกใบรับรอง:

Openssl x509 -req -in device.csr -CA rootCA.pem -CAkey rootCA.key -CAcreateserial -out device.crt -วัน $NUM_OF_DAYS -sha256 -extfile /tmp/__v3.ext
เปลี่ยนชื่อใบรับรองและลบไฟล์ชั่วคราว:

Mv device.csr $DOMAIN.csr cp device.crt $DOMAIN.crt # ลบไฟล์ชั่วคราว rm -f device.crt;
สคริปต์พร้อมแล้ว มาเปิดตัวกัน:

./create_certificate_for_domain.sh mysite.localhost
เราได้รับสองไฟล์: mysite.localhost.crtและ อุปกรณ์.คีย์

ตอนนี้คุณต้องระบุ เว็บเซิร์ฟเวอร์เส้นทางไปยังไฟล์เหล่านี้ เมื่อใช้ nginx เป็นตัวอย่าง จะมีลักษณะดังนี้:

เราเปิดเบราว์เซอร์ เปิด https://mysite.localhost และดู:

เบราว์เซอร์ไม่เชื่อถือใบรับรองนี้ ฉันควรทำอย่างไรดี?

เราจำเป็นต้องทำเครื่องหมายใบรับรองที่เราออกให้ว่าเชื่อถือได้ บน Linux (Ubuntu และอาจเป็นรุ่นที่ใช้ Debian อื่นๆ) สามารถทำได้ผ่านเบราว์เซอร์เอง บน Mac OS X สามารถทำได้ผ่านแอปพลิเคชัน Keychain Access เปิดแอปพลิเคชันแล้วลากไฟล์ไปที่หน้าต่าง mysite.localhost.crt- จากนั้นเปิดไฟล์ที่เพิ่มแล้วเลือกเชื่อถือเสมอ:

รีเฟรชหน้าในเบราว์เซอร์และ:

ความสำเร็จ! เบราว์เซอร์เชื่อถือใบรับรองของเรา

แบ่งปันในความคิดเห็น คุณใช้ https เพื่อการพัฒนาท้องถิ่นหรือไม่?

แม็กซิม คอฟตุน
หัวหน้าฝ่ายพัฒนา

ในแพลตฟอร์มและอุปกรณ์ต่างๆ มักจะต้องนำเสนอในรูปแบบที่แตกต่างกัน ตัวอย่างเช่น เซิร์ฟเวอร์ Windows ใช้ไฟล์ PFX เพื่อ เซิร์ฟเวอร์อาปาเช่ต้องใช้ไฟล์ PEM ที่มีนามสกุล .crt หรือ .cer ในบทความนี้ เราจะช่วยให้คุณเข้าใจปัญหาต่อไปนี้:

• รูปแบบใบรับรอง SSL ที่แตกต่างกันมีอะไรบ้าง?
• อะไรคือความแตกต่าง?
• จะแปลงใบรับรอง SSL จากรูปแบบหนึ่งไปเป็นอีกรูปแบบหนึ่งได้อย่างไร

ภาพรวมของรูปแบบใบรับรอง SSL

รูปแบบใบรับรอง PEM

พี.อี.เอ็ม.– รูปแบบที่นิยมมากที่สุดในหมู่ศูนย์รับรอง ใบรับรอง PEM อาจมีนามสกุล .pem, .crt, .cer และ .key(ไฟล์คีย์ส่วนตัว) เป็นไฟล์ ASCII ที่เข้ารหัสโดยใช้รูปแบบ Base64 เมื่อคุณเปิดไฟล์ pem ในโปรแกรมแก้ไขข้อความ คุณจะเห็นว่าข้อความโค้ดในนั้นเริ่มต้นด้วยแท็ก “—— BEGIN CERTIFICATE ——” และลงท้ายด้วยแท็ก “—— END CERTIFICATE ——“

Apache และเซิร์ฟเวอร์อื่นที่คล้ายคลึงกันใช้ใบรับรองในรูปแบบ PEM โปรดทราบว่าไฟล์หนึ่งอาจมีใบรับรอง SSL หลายใบและแม้แต่รหัสส่วนตัว โดยอีกไฟล์หนึ่งอยู่ใต้อีกไฟล์หนึ่ง ในกรณีนี้ แต่ละใบรับรองจะถูกแยกออกจากใบรับรองอื่นๆ ก่อนหน้านี้ แท็กที่ระบุเริ่มต้นและสิ้นสุด ตามกฎแล้วสำหรับ การติดตั้ง SSLใบรับรอง Apache ใบรับรอง และคีย์ส่วนตัวต้องอยู่ในไฟล์ที่แตกต่างกัน

รูปแบบใบรับรอง DER

รูปแบบ DERเป็นประเภทใบรับรองไบนารีแทนรูปแบบ PEM นามสกุลไฟล์ที่ใช้กันมากที่สุดในรูปแบบ PEM คือ .เซอร์แต่บางครั้งคุณก็อาจพบนามสกุลไฟล์ด้วย .เดอร์- ดังนั้น หากต้องการแยกใบรับรอง SSL ในรูปแบบ PEM จากรูปแบบ DER คุณควรเปิดใบรับรองนั้นในโปรแกรมแก้ไขข้อความและค้นหาแท็กเริ่มต้นและสิ้นสุดของใบรับรอง (BEGIN/END) โดยทั่วไปใบรับรอง DER SSL จะใช้บนแพลตฟอร์ม Java

ใบรับรอง PKCS#7/P7B

ใบรับรอง SSL ในรูปแบบ PKCS#7 หรือ P7Bเป็นไฟล์ที่จัดเก็บในรูปแบบ Base64 ASCII และมีนามสกุลไฟล์ .p7b หรือ .p7c- ใบรับรอง P7B ประกอบด้วยแท็กเริ่มต้นใบรับรอง “—— BEGIN PKCS7 ——” และแท็กปิดท้ายใบรับรอง “—— END PKCS7 ——“ ไฟล์ในรูปแบบ P7B จะมีเฉพาะใบรับรอง SSL และใบรับรอง SSL ระดับกลางเท่านั้น รหัสส่วนตัวในขณะเดียวกันมันก็ไป แยกไฟล์- ใบรับรอง SSL ในรูปแบบ PKCS#7/P7B รองรับแพลตฟอร์มต่อไปนี้: ไมโครซอฟต์ วินโดวส์และจาวาทอมแคท

ใบรับรอง PFX (รูปแบบ PKCS#12)

รูปแบบใบรับรอง SSL พีเคซีเอส#12หรือที่เรียกกันว่า ใบรับรอง PFX- รูปแบบไบนารี่ เมื่อใช้ในไฟล์ที่เข้ารหัสไฟล์เดียว ไม่ใช่แค่ไฟล์ของคุณเท่านั้น ใบรับรองส่วนบุคคลเซิร์ฟเวอร์และใบรับรองระดับกลางของผู้ออกใบรับรอง แต่ยังรวมถึงรหัสส่วนตัวของคุณด้วย ไฟล์ PFX มักจะมีนามสกุล .pfx หรือ .p12- โดยทั่วไปแล้ว ไฟล์ PFX จะถูกนำมาใช้ เซิร์ฟเวอร์วินโดวส์เพื่อนำเข้าและส่งออกไฟล์ใบรับรอง SSL และคีย์ส่วนตัวของคุณ

การแปลงใบรับรอง SSL เป็น OpenSSL

คำสั่ง OpenSSL เหล่านี้ทำให้สามารถแปลงใบรับรองและคีย์ได้ รูปแบบที่แตกต่างกัน- เพื่อให้เข้ากันได้กับเซิร์ฟเวอร์หรือซอฟต์แวร์บางประเภท ตัวอย่างเช่น คุณต้องแปลงไฟล์ PEM ปกติที่จะทำงานกับ Apache เป็นรูปแบบ PFX (PKCS # 12) เพื่อใช้กับ Tomcat หรือ IIS

• แปลง PEM เป็น DER
  

  openssl x509 -outform der -incertificate.pem -outcertificate.der

• แปลง PEM เป็น P7B
  

  openssl crl2pkcs7 -nocrl -certfile ใบรับรองcer - ออกใบรับรอง p7b -certfile CACert.cer

• แปลง PEM เป็น PFX
  

  openssl pkcs12 - ส่งออก - ออกใบรับรอง pfx -inkey privateKey.key - ในใบรับรอง crt -certfile CACert.crt

• แปลง DER เป็น PEM
  

  openssl x509 -inform der -inใบรับรองcer -ออกใบรับรองpem

• แปลง P7B เป็น PEM
  

  openssl pkcs7 -print_certs -ในใบรับรอง p7b -ออกใบรับรองcer

• แปลง P7B เป็น PFX
  

  เปิดในหน้าต่าง

• แปลง PFX เป็น PEM
  

  openssl pkcs12 -in ใบรับรอง pfx - ออก ใบรับรอง cer -nodes

ตัวแปลงใบรับรอง SSL ออนไลน์

นอกจากนี้ยังมี โปรแกรมออนไลน์เพื่อแปลงใบรับรอง SSL จากรูปแบบหนึ่งไปเป็นอีกรูปแบบหนึ่ง ตัวอย่างเช่น เราสามารถแนะนำตัวแปลง SSL จาก SSLShopper

ใช้ตัวแปลง SSL นี้เพื่อแปลงใบรับรอง SSL รูปแบบต่างๆเช่น PEM, DER, P7B และ PFX หากต้องการใช้ตัวแปลง SSL เพียงเลือกไฟล์ใบรับรองและประเภทปัจจุบันของไฟล์นั้น (กำหนดโดยรูปแบบส่วนขยาย) จากนั้นเลือกรูปแบบที่คุณต้องการแปลงใบรับรอง SSL แล้วคลิกปุ่ม “แปลงใบรับรอง”

โปรดทราบว่าคุณจะต้องใช้ไฟล์เอาต์พุตที่แตกต่างกัน ขึ้นอยู่กับรูปแบบที่คุณต้องการแปลงใบรับรอง SSL

แปลง PEM เป็น DER

หากต้องการแปลงใบรับรองมาตรฐานในรูปแบบ PEM เป็นรูปแบบ DER ไบนารี คุณจำเป็นต้องมีไฟล์ใบรับรอง SSL เท่านั้น โดยปกติแล้ว คุณจะได้รับมันในไฟล์เก็บถาวรพร้อมกับใบรับรองระดับกลาง ตามกฎแล้ว ชื่อจะประกอบด้วยชื่อโดเมนของคุณ

แปลง PEM เป็น P7B / PKCS#7

หากคุณต้องการแปลงใบรับรอง SSL มาตรฐานเป็นไฟล์ในรูปแบบ P7B / PKCS#7 นอกเหนือจากใบรับรอง SSL ของโดเมนของคุณแล้ว คุณยังสามารถอัปโหลดไฟล์ที่มีกลุ่มใบรับรองได้อีกด้วย เราได้เขียนรายละเอียดเพิ่มเติมเกี่ยวกับกลุ่มใบรับรอง SSL ในบทความเกี่ยวกับ CA-bundle

แปลง PEM เป็น PFX / PKCS#12

โปรดทราบว่าสำหรับการแปลง รูปแบบมาตรฐานสำหรับใบรับรอง SSL คุณต้องเพิ่มไฟล์อีกหนึ่งไฟล์ - คีย์ส่วนตัวของคุณ คีย์ส่วนตัวคือ ข้อมูลที่เป็นความลับซึ่งคุณเท่านั้นที่ควรมี ดังนั้นหน่วยงานออกใบรับรองจะไม่ส่งเอกสารดังกล่าวไปพร้อมกับไฟล์ใบรับรองของคุณ
รหัสส่วนตัวจะถูกสร้างขึ้นในเวลาที่มีการสร้างคำขอ CSR หากคุณสร้าง CSR บนเซิร์ฟเวอร์ของคุณ คีย์ควรได้รับการบันทึกไว้โดยอัตโนมัติ หากคุณสร้างคำขอ CSR ในเครื่องมือพิเศษบนเว็บไซต์ของเรา (บนหน้าที่เชื่อมโยงหรือในขณะที่กรอกข้อมูลทางเทคนิค) รหัสจะแสดงให้คุณเห็นเมื่อสิ้นสุดการสร้าง CSR (หรือการป้อนข้อมูลทางเทคนิค) แต่จะไม่ถูกเก็บไว้ใน ฐานข้อมูลของเรา ดังนั้นจึงเป็นสิ่งสำคัญที่คุณจะต้องเก็บรหัสส่วนตัวด้วยตัวเอง