สร้างคีย์และใบรับรองสำหรับ SSO

Google Workspace มีบริการการลงชื่อเพียงครั้งเดียว (SSO) สำหรับลูกค้าที่ใช้ Google Workspace หรือ Google Workspace for Education บริการการลงชื่อเพียงครั้งเดียวของ Google Workspace ยอมรับคีย์สาธารณะและใบรับรองที่สร้างขึ้นด้วยอัลกอริทึม RSA หรือ DSA หากต้องการใช้ บริการ คุณต้องสร้างชุดคีย์สาธารณะและคีย์ส่วนตัว รวมถึงใบรับรอง X.509 ที่มีคีย์สาธารณะ เมื่อมีคีย์สาธารณะหรือ ใบรับรองแล้ว คุณจะต้องลงทะเบียนกับ Google คุณทำได้โดย เพียงอัปโหลดคีย์หรือใบรับรองผ่านคอนโซลผู้ดูแลระบบของ Google

วิธีสร้างคีย์และใบรับรองมักจะขึ้นอยู่กับแพลตฟอร์มการพัฒนา และค่ากำหนดภาษาโปรแกรม คุณสร้างคีย์และใบรับรองที่บริการ SSO ของ Google Workspace ต้องการได้หลายวิธีดังนี้

การใช้ OpenSSL

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

สร้างคีย์ส่วนตัว RSA

การสร้างคีย์ส่วนตัว RSA ด้วย OpenSSL ประกอบด้วยขั้นตอนเดียว ดังนี้

openssl genrsa -out rsaprivkey.pem 2048

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

การติดตั้งใช้งานบางอย่าง โดยเฉพาะที่ใช้ Java อาจต้องใช้ DER หรือ PKCS8 ซึ่งคุณ สร้างได้โดยใช้ขั้นตอนเพิ่มเติมต่อไปนี้

1. openssl rsa -in rsaprivkey.pem -pubout -outform DER -out rsapubkey.der
2. openssl pkcs8 -topk8 -inform PEM -outform DER -in rsaprivkey.pem -out rsaprivkey.der -nocrypt

ขั้นตอนที่ 1 จะสร้างคีย์สาธารณะในรูปแบบ DER

ขั้นตอนที่ 2 จะสร้างคีย์ส่วนตัวในรูปแบบ pkcs8 และ DER เมื่อสร้างแล้ว คุณจะใช้คีย์เหล่านี้ (rsapubkey.der และ rsaprivkey.der) ได้

สร้างคีย์ส่วนตัว DSA

การสร้างคีย์ DSA มี 2 ขั้นตอนดังนี้

1. openssl dsaparam -out dsaparam.pem 2048
2. openssl gendsa -out dsaprivkey.pem dsaparam.pem

ขั้นตอนแรกจะสร้างไฟล์พารามิเตอร์ DSA, dsaparam.pem ซึ่งในกรณีนี้ จะสั่งให้ OpenSSL สร้างคีย์ 2048 บิตในขั้นตอนที่ 2 ไฟล์ dsaparam.pem ไม่ใช่คีย์และสามารถทิ้งได้หลังจากสร้างคีย์สาธารณะและคีย์ส่วนตัวแล้ว ขั้นตอนที่ 2 จะสร้างคีย์ส่วนตัวในไฟล์ dsaprivkey.pem ซึ่งควรเก็บไว้เป็นความลับ

หากต้องการส่งออกคีย์เป็นรูปแบบ DER (ไบนารี) ให้ทำตามขั้นตอนต่อไปนี้

1. openssl dsa -in dsaprivkey.pem -outform DER -pubout -out dsapubkey.der
2. openssl pkcs8 -topk8 -inform PEM -outform DER -in dsaprivkey.pem -out dsaprivkey.der -nocrypt

ขั้นตอนที่ 1 จะแตกคีย์สาธารณะออกเป็นรูปแบบ DER

ขั้นตอนที่ 2 จะแปลงคีย์ส่วนตัวเป็นรูปแบบ pkcs8 และ DER เมื่อดำเนินการเสร็จแล้ว คุณจะใช้คู่คีย์สาธารณะ (dsapubkey.der) และส่วนตัว (dsaprivkey.der) นี้ได้

สร้างใบรับรอง

เมื่อมีคู่คีย์แล้ว คุณก็สร้างใบรับรอง X.509 ได้ง่ายๆ ใบรับรองมีคีย์สาธารณะที่เกี่ยวข้องพร้อมกับข้อมูลเมตาบางอย่าง ที่เกี่ยวข้องกับองค์กรที่สร้างใบรับรอง ทำตามขั้นตอนนี้เพื่อ สร้างใบรับรองที่ลงนามด้วยตนเองจากคีย์ส่วนตัว RSA หรือ DSA

openssl req -new -x509 -key dsaprivkey.pem -out dsacert.pem

หลังจากตอบคำถามจำนวนหนึ่งแล้ว ระบบจะสร้างใบรับรองและ บันทึกเป็น dsacert.pem นี่คือไฟล์ที่คุณอัปโหลดไปยัง Google Workspace ผ่าน แผงควบคุมเมื่อกำหนดค่า SSO

สร้างลายนิ้วมือของใบรับรอง

แอปพลิเคชันบางอย่างต้องใช้ลายนิ้วมือของใบรับรอง X.509 แทนที่จะเป็นใบรับรอง X.509 เอง ลายนิ้วมือคือไดเจสต์ของใบรับรองในรูปแบบไบนารี x509 ประเภทฟิงเกอร์ปรินต์ขึ้นอยู่กับอัลกอริทึมที่ใช้สร้าง ฟิงเกอร์ปรินต์ เช่น SHA-1 หรือ SHA-256

หากต้องการสร้างฟิงเกอร์ปรินต์ SHA-256 จากใบรับรอง X.509 ให้ใช้คำสั่งต่อไปนี้ (แทนที่ชื่อไฟล์ .pem ของใบรับรองจริง)

openssl x509 -noout -fingerprint -sha256 -inform pem -in "GoogleIDPCertificate-domain.com.pem"

การใช้ Microsoft Visual Studio สำหรับ .NET

Microsoft Visual Studio 2005 มีเครื่องมือ (ในไดเรกทอรี Common7ToolsBin ) ที่ใช้สร้างใบรับรองสำหรับใช้กับ Google Workspace ได้ ทำตามขั้นตอนด้านล่างเพื่อสร้างคู่คีย์และใบรับรองสาธารณะและส่วนตัวใน .NET

1. makecert -r -pe -n "CN=Test Certificate" -sky exchange -sv testcert.pvk testcert.cer
2. pvk2pfx -pvk testcert.pvk -spc testcert.cer -pfx testcert.pfx

คำสั่งด้านบนจะใช้อัลกอริทึม RSA โดยค่าเริ่มต้น ขั้นตอนที่ 1 ใช้เครื่องมือการสร้างใบรับรอง (makecert.exe) เพื่อสร้างใบรับรอง X.509 ที่ลงนามด้วยตนเองชื่อ testcert.cer และคีย์ส่วนตัวที่เกี่ยวข้อง

ขั้นตอนที่ 2 ใช้เครื่องมือ pvk2pfx (pvk2pfx.exe) เพื่อสร้างไฟล์ Personal Information Exchange (PFX) จากไฟล์ CER และ PVK โดยที่ PFX จะมีทั้งคีย์สาธารณะและคีย์ส่วนตัว

คุณสามารถอัปโหลดไฟล์ testcert.cer ที่สร้างในขั้นตอนที่ 1 ไปยัง Google Workspace โดยใช้แผงควบคุม และใช้ไฟล์ testcert.pfx จากขั้นตอนที่ 2 เพื่อสร้างอินสแตนซ์ X509Certificate2 (.NET 2.0+) สำหรับการลงนามในการตอบกลับ SAML

การใช้ Keytool ใน Java

นักพัฒนาซอฟต์แวร์ Java สามารถใช้ยูทิลิตี keytool ที่อยู่ใน JDK มาตรฐานเพื่อสร้างคู่คีย์สาธารณะ/ส่วนตัวและใบรับรอง X.509 ได้ keytool เป็นยูทิลิตีการจัดการคีย์และใบรับรองที่ช่วยให้ผู้ใช้ดูแลคู่คีย์สาธารณะ/ส่วนตัวและใบรับรองที่เกี่ยวข้องของตนเองเพื่อใช้ในรูปแบบการตรวจสอบสิทธิ์ที่ต้องใช้ลายเซ็นดิจิทัล keytoolจะจัดเก็บคีย์และใบรับรองใน "ที่เก็บคีย์" ซึ่งสำหรับการติดตั้งใช้งานเริ่มต้นก็คือไฟล์ (.keystore) ในไดเรกทอรีหน้าแรกของผู้ใช้ ทั้งนี้ คีย์ส่วนตัวจะรักษาความปลอดภัยด้วยรหัสผ่าน

สร้างคู่คีย์ DSA

1. keytool -genkey -alias dsassokey -keyalg "DSA" -keysize 2048 -validity 180 -sigalg "SHA256withDSA"
2. keytool -export -alias dsassokey -file dsasso.cer

ขั้นตอนที่ 1 สร้างคู่คีย์สาธารณะ/ส่วนตัวที่มีขนาด 2048 และมีอายุ 180 วันโดยใช้อัลกอริทึม DSA

ขั้นตอนที่ 2 จะสร้างใบรับรอง X.509 (dsasso.cer) จากคีย์สาธารณะ จากนั้นให้อัปโหลด dsasso.cer ไปยัง Google Workspace โดยใช้แผงควบคุม

สร้างคู่คีย์ RSA

1. keytool -genkey -alias rsassokey -keyalg "RSA" -keysize 2048 -validity 180
2. keytool -export -alias rsassokey -file rsasso.cer

ขั้นตอนที่ 1 จะสร้างคู่คีย์สาธารณะ/ส่วนตัวที่มีขนาด 2048 และมีอายุ 180 วันโดยใช้อัลกอริทึม RSA

ขั้นตอนที่ 2 จะสร้างใบรับรอง X.509 (rsasso.cer) จากคีย์สาธารณะ จากนั้นอัปโหลด rsasso.cer ไปยัง Google Workspace โดยใช้แผงควบคุม

การใช้ Java Cryptography Architecture

Java Cryptography Architecture (JCA) มีคลาสและอินเทอร์เฟซหลักสำหรับ สร้างและจัดการพร็อพเพอร์ตี้ความปลอดภัย JCA ครอบคลุมส่วนต่างๆ ของ Java 2 SDK Security API ที่เกี่ยวข้องกับวิทยาการเข้ารหัส การใช้ API นี้จะช่วยให้คุณ สร้างคู่คีย์สาธารณะและส่วนตัวในอัลกอริทึมที่ต้องการได้อย่างง่ายดาย ด้านล่างนี้คือ โค้ดตัวอย่างที่สร้างคีย์ DSA หรือ RSA เพื่อใช้กับ บริการ SSO ของ Google Workspace

สร้างคู่คีย์สาธารณะและคีย์ส่วนตัว

import java.io.*;
import java.security.*;

public class KeyGenDSA {

  public static void main(String[] args) {
        try {
          KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA");
          SecureRandom random = SecureRandom.getInstanceStrong();
          keyGen.initialize(2048, random);

          KeyPair pair = keyGen.generateKeyPair();
          PrivateKey priv = pair.getPrivate();
          PublicKey pub = pair.getPublic();

          byte[] encPriv = priv.getEncoded();
          FileOutputStream privfos = new FileOutputStream("DSAPrivateKey.key");
          privfos.write(encPriv);
          privfos.close();

          byte[] encPub = pub.getEncoded();
          FileOutputStream pubfos = new FileOutputStream("DSAPublicKey.key");
          pubfos.write(encPub);
          pubfos.close();

   } catch (Exception e) {
         e.printStackTrace();
   }
  }
}

โค้ดด้านบนใช้ KeyPairGenerator เพื่อสร้างคู่คีย์ DSA คีย์ที่สร้างขึ้นจะอยู่ในรูปแบบไบนารีและจะแสดงในไฟล์แต่ละไฟล์ เมื่อมีคีย์แล้ว คุณจะลงทะเบียนคีย์สาธารณะกับ Google Workspace และใช้คีย์ส่วนตัวเพื่อลงนามใน SAMLResponse ได้ หากต้องการ สร้างคู่คีย์ RSA แทน DSA สิ่งที่คุณต้องทำคือแทนที่ "DSA" ในโค้ดด้วย "RSA"

ลงทะเบียนใบรับรองหรือคีย์สาธารณะกับ Google Workspace

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