สร้างคีย์และใบรับรองสำหรับ 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" ซึ่งสำหรับการใช้งานเริ่มต้นจะเป็นเพียงไฟล์ (.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 ด้วยผู้ให้บริการข้อมูลประจำตัวบุคคลที่สาม