สร้างคีย์และใบรับรองสำหรับ 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 ไม่ใช่คีย์และสามารถลบทิ้งได้หลังจากสร้างคีย์สาธารณะและคีย์ส่วนตัวแล้ว ส่วนขั้นตอนที่สองจะสร้างคีย์ส่วนตัวขึ้นมาในไฟล์ 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 ได้ง่ายๆ โดยใบรับรองจะเก็บคีย์สาธารณะที่เกี่ยวข้องไว้ พร้อมกับข้อมูลเมตา บางอย่างที่เกี่ยวข้องกับองค์กรที่สร้างใบรับรอง โปรดทำตามขั้นตอนนี้เพื่อ สร้างใบรับรองแบบ Self-signed จากคีย์ส่วนตัว 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 แบบ Self-signed ชื่อ 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 1 คู่ คีย์ที่สร้างขึ้นจะอยู่ในรูปแบบไบนารีและส่งออกเป็นคนละไฟล์ เมื่อมีคีย์แล้ว คุณก็จดทะเบียนคีย์สาธารณะกับ Google Workspace และใช้คีย์ส่วนตัวเพื่อลงนาม SAMLResponse ได้ หากต้องการสร้างคู่คีย์ RSA แทน DSA คุณก็แค่แทนที่ "DSA" ในโค้ดด้วย "RSA"

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

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