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

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

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

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