Den här sidan översattes av Cloud Translation API:et.

Generera nycklar och certifikat för SSO

Google Workspace erbjuder tjänsten Single Sign-On (SSO) till kunder med Google Workspace eller Google Workspace for Education. Google Workspaces tjänst Single Sign-On accepterar offentliga nycklar och certifikat som genereras med antingen RSA- eller DSA-algoritmen. För att använda tjänsten måste du generera en uppsättning offentliga och privata nycklar och ett X.509-certifikat som innehåller den offentliga nyckeln. När du har en offentlig nyckel eller ett certifikat måste du registrera det hos Google. Du kan göra detta genom att helt enkelt ladda upp nyckeln eller certifikatet via Googles administratörskonsol.

Hur du genererar nycklar och certifikat beror ofta på din utvecklingsplattform och dina preferenser för programmeringsspråk. Här är flera olika sätt att generera de nycklar och certifikat som behövs av Google Workspace SSO-tjänsten.

Använda OpenSSL

Även om det finns många metoder för att skapa publika och privata nyckelpar, är OpenSSL-verktyget med öppen källkod ett av de mest populära. Det har portats till alla större plattformar och tillhandahåller ett enkelt kommandoradsgränssnitt för nyckelgenerering.

Skapa den privata RSA-nyckeln

Generering av privata RSA-nycklar med OpenSSL innebär bara ett steg:

openssl genrsa -out rsaprivkey.pem 2048

Det här kommandot genererar en PEM-kodad privat nyckel och lagrar den i filen rsaprivkey.pem . Det här exemplet skapar en 2048-bitars nyckel, som bör fungera för nästan alla ändamål. Den resulterande privata nyckeln bör hållas hemlig och används för att signera och dekryptera data.

Vissa implementeringar, särskilt Java-baserade, kan kräva DER eller PKCS8, vilket till exempel kan genereras med följande ytterligare steg:

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

Steg 1 genererar den publika nyckeln i DER-format.

Steg 2 genererar den privata nyckeln i pkcs8- och DER-format. När den har genererats kan du använda dessa nycklar ( rsapubkey.der och rsaprivkey.der ).

Skapa en DSA-privat nyckel

Generering av DSA-nyckel innebär två steg:

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

Det första steget skapar en DSA-parameterfil, dsaparam.pem , som i det här fallet instruerar OpenSSL att skapa en 2048-bitars nyckel i steg 2. Filen dsaparam.pem är inte i sig en nyckel och kan kasseras efter att de publika och privata nycklarna har skapats. Det andra steget skapar faktiskt den privata nyckeln i filen dsaprivkey.pem , vilken bör hållas hemlig.

För att exportera nyckeln till ett DER-format (binärt) kan du följa följande steg:

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

Steg 1 extraherar den publika nyckeln till ett DER-format.

Steg 2 konverterar den privata nyckeln till pkcs8- och DER-format. När du har gjort detta kan du använda det offentliga ( dsapubkey.der ) och privata ( dsaprivkey.der ) nyckelparet.

Skapa ett certifikat

När du väl har ditt nyckelpar är det enkelt att skapa ett X.509-certifikat. Certifikatet innehåller motsvarande publika nyckel, tillsammans med metadata som rör organisationen som skapade certifikatet. Följ det här steget för att skapa ett självsignerat certifikat från antingen en privat RSA- eller DSA-nyckel:

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

När du har svarat på ett antal frågor skapas och sparas certifikatet som dsacert.pem . Det här är filen du laddar upp till Google Workspace via kontrollpanelen när du konfigurerar SSO.

Skapa ett certifikatfingeravtryck

Vissa applikationer kräver ett fingeravtryck för ett X.509-certifikat, snarare än själva X.509-certifikatet. Ett fingeravtryck är en sammanfattning av certifikatet i binärt x509-format. Fingeravtryckstypen beror på vilken algoritm som används för att generera fingeravtrycket, till exempel SHA-1 eller SHA-256.

För att skapa ett SHA-256-fingeravtryck från ett X.509-certifikat, använd följande kommando (och ersätt ditt faktiska certifikats .pem-filnamn):

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

Använda Microsoft Visual Studio för .NET

Microsoft Visual Studio 2005 tillhandahåller verktyg (i katalogen Common7ToolsBin ) som kan användas för att generera ett certifikat för användning med Google Workspace. Följ stegen nedan för att skapa det offentliga och privata nyckelparet och certifikatet i .NET:

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

Som standard används RSA-algoritmen i kommandona ovan. Steg 1 använder verktyget för att skapa certifikat ( makecert.exe ) för att skapa ett självsignerat X.509-certifikat med namnet testcert.cer och motsvarande privata nyckel.

Steg 2 använder pvk2pfx- verktyget ( pvk2pfx.exe ) för att skapa en PFX-fil (Personal Information Exchange) från en CER- och PVK-fil. PFX-filen innehåller både din publika och privata nyckel.

testcert.cer filen som skapades i steg 1 kan laddas upp till Google Workspace med hjälp av kontrollpanelen; och testcert.pfx från steg 2 kan användas för att skapa en X509Certificate2 instans (.NET 2.0+) för att signera SAML-svaret.

Använda Keytool i Java

Java-utvecklare kan använda keytool verktyget som finns i standard-JDK för att skapa det offentliga/privata nyckelparet och X.509-certifikatet. keytool är ett nyckel- och certifikathanteringsverktyg som låter användare administrera sina egna offentliga/privata nyckelpar och tillhörande certifikat för användning i autentiseringsscheman som kräver digitala signaturer. keytool lagrar nycklar och certifikat i en "nyckelbutik" som för standardimplementeringen helt enkelt är en fil ( .keystore ) i användarens hemkatalog. Privata nycklar skyddas med lösenord.

Skapa DSA-nyckelpar

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

Steg 1 genererar ett offentligt/privat nyckelpar med storleken 2048 och en giltighetstid på 180 dagar med hjälp av DSA-algoritmen.

Steg 2 genererar ett X.509-certifikat ( dsasso.cer ) från den publika nyckeln. Du laddar sedan upp dsasso.cer till Google Workspace med hjälp av kontrollpanelen.

Skapa RSA-nyckelpar

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

Steg 1 genererar ett offentligt/privat nyckelpar med storleken 2048 och en giltighetstid på 180 dagar med hjälp av RSA-algoritmen.

Steg 2 genererar ett X.509-certifikat ( rsasso.cer ) från den publika nyckeln. Du laddar sedan upp rsasso.cer till Google Workspace med hjälp av kontrollpanelen.

Använda Java-kryptografiarkitektur

Java Cryptography Architecture (JCA) tillhandahåller kärnklasser och gränssnitt för att generera och manipulera säkerhetsegenskaper. JCA omfattar de delar av Java 2 SDK Security API som är relaterade till kryptografi. Med hjälp av detta API kan du enkelt generera offentliga och privata nyckelpar i önskad algoritm. Nedan följer ett exempel på kod som skapar DSA- eller RSA-nycklar som ska användas med Google Workspace SSO-tjänsten.

Skapa ett offentligt och privat nyckelpar

import java.io.&#42;;
import java.security.&#42;;

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();
   }
  }
}

Koden ovan använder KeyPairGenerator för att skapa ett par DSA-nycklar. De genererade nycklarna kommer att vara i binärt format och matas ut i individuella filer. När du har nycklarna kan du registrera den offentliga nyckeln hos Google Workspace och använda den privata nyckeln för att signera din SAMLResponse . För att generera ett par RSA-nycklar istället för DSA behöver du bara ersätta "DSA" i koden med "RSA" .

Registrera ditt certifikat eller din offentliga nyckel med Google Workspace

När du har gjort den knepiga delen med att generera nycklar och certifikat är nästa del riktigt enkel. För att registrera ditt certifikat eller din offentliga nyckel med Google Workspace måste du gå till administratörskonsolen och logga in som administratör. Välj Säkerhet , sedan Konfigurera enkel inloggning (SSO) och fyll i alla fält på sidan under Konfigurera SSO med tredjepartsidentitetsleverantör .

Generera nycklar och certifikat för SSO Stay organized with collections Save and categorize content based on your preferences.