Beispiel: Zufallsdaten mit der Funktion GenerateRandomRequest() generieren

GREP11-API unterstützt Programmiersprachen mit gRPC-Bibliotheken. Zum Testen der GREP11-API stehen zwei GitHub-Beispielrepositorys zur Verfügung:

• Das GitHub-Beispielrepository für Golang
• Das GitHub-Beispielrepository für JavaScript

Mit dem folgenden Golang-Codebeispiel können Sie Zufallsdaten generieren, indem Sie die Funktion GenerateRandom aufrufen.

In diesem Beispiel wird davon ausgegangen, dass zusätzliche erforderliche Golang-Pakete über Importanweisungen wie die gRPC-und http-Pakete eingeschlossen werden. Die Anweisung import pb "github.com/IBM-Cloud/hpcs-grep11-go/grpc" wird von GREP11 verwendet, um API-Funktionsaufrufe auszuführen.

import pb "github.com/IBM-Cloud/hpcs-grep11-go/grpc"

// Data structure and supporting methods used for GREP11 authentication
// IAMPerRPCCredentials type defines the fields required for IBM Cloud IAM authentication
// This type implements the gRPC PerRPCCredentials interface

type IAMPerRPCCredentials struct {
	expiration  time.Time
	updateLock  sync.Mutex
	AccessToken string // Required if APIKey nor Endpoint are specified - IBM Cloud IAM access token
	APIKey      string // Required if AccessToken is not specified - IBM Cloud API key
	Endpoint    string // Required if AccessToken is not specified - IBM Cloud IAM endpoint
}

// GetRequestMetadata is used by GRPC for authentication
func (cr *IAMPerRPCCredentials) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
	// Set token if empty or Set token if expired
	if len(cr.APIKey) != 0 && len(cr.Endpoint) != 0 && time.Now().After(cr.expiration) {
		if err := cr.getToken(ctx); err != nil {
			return nil, err
		}
	}

	return map[string]string{
		"authorization":    cr.AccessToken,
	}, nil
}

// RequireTransportSecurity is used by gRPC for authentication
func (cr *IAMPerRPCCredentials) RequireTransportSecurity() bool {
	return true
}

// getToken obtains a bearer token and the expiration
func (cr *IAMPerRPCCredentials) getToken(ctx context.Context) (err error) {
	cr.updateLock.Lock()
	defer cr.updateLock.Unlock()

	// Check if another thread has updated the token
	if time.Now().Before(cr.expiration) {
		return nil
	}

	var req *http.Request
	client := http.Client{}
	requestBody := []byte("grant_type=urn:ibm:params:oauth:grant-type:apikey&apikey=" + cr.APIKey)

	req, err = http.NewRequest("POST", cr.Endpoint+"/identity/token", bytes.NewBuffer(requestBody))
	if err != nil {
		return err
	}

	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req = req.WithContext(ctx)
	resp, err := client.Do(req)
	if err != nil {
		return err
	}

	respBody, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return fmt.Errorf("failed to read response body: %s", err)
	}
	defer resp.Body.Close()

	iamToken := struct {
		AccessToken string `json:"access_token"`
		ExpiresIn   int32  `json:"expires_in"`
	}{}

	err = json.Unmarshal(respBody, &iamToken)
	if err != nil {
		return fmt.Errorf("error unmarshaling response body: %s", err)
	}

	cr.AccessToken = fmt.Sprintf("Bearer %s", iamToken.AccessToken)
	cr.expiration = time.Now().Add((time.Duration(iamToken.ExpiresIn - 60)) * time.Second)

	return nil
}

// Generating a GREP11 API function call

// The following IBM Cloud items need to be changed prior to running the sample program
const address = "<grep11_server_address>"

var callOpts = []grpc.DialOption{
  grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})),
  grpc.WithPerRPCCredentials(&util.IAMPerRPCCredentials{
    APIKey:   "<ibm_cloud_apikey>",
    Endpoint: "https://iam.cloud.ibm.com",
  }),
}

conn, err := grpc.Dial(address, callOpts...)
if err != nil {
		panic(fmt.Errorf("Could not connect to server: %s", err))
}
defer conn.Close()

cryptoClient := pb.NewCryptoClient(conn)

rngTemplate := &pb.GenerateRandomRequest{
		Len: (uint64)(ep11.AES_BLOCK_SIZE),
}

// Generate 16 bytes of random data for the initialization vector
rng, err := cryptoClient.GenerateRandom(context.Background(), rngTemplate)
if err != nil {
		panic(fmt.Errorf("GenerateRandom Error: %s", err))
}
iv := rng.Rnd[:ep11.AES_BLOCK_SIZE]
fmt.Println("Generated IV")

Aktualisieren Sie im Beispiel die folgenden Variablen:

• Ersetzen Sie <grep11_server_address> durch den Wert Ihres API-Endpunkts GREP11. Zum Suchen der Serviceendpunkt-URL klicken Sie in der Benutzerschnittstelle Ihrer bereitgestellten Serviceinstanz auf Übersicht > Connect > Enterprise PKCS #11 -Endpunkt-URL. Alternativ können Sie die API-Endpunkt-URL dynamisch abrufen. Der zurückgegebene Wert enthält Folgendes. Wählen Sie abhängig davon, ob Sie ein öffentliches oder privates Netz verwenden, den Wert für den öffentlichen oder privaten Serviceendpunkt aus, der im Abschnitt ep11 zurückgegeben wird.

  {
    "instance_id": "<instance_ID>",
    "kms": {
      "public": "<instance_ID>.api.<region>.hs-crypto.appdomain.cloud",
      "private":"<instance_ID>.api.private.<region>.hs-crypto.appdomain.cloud"
    },
    "ep11": {
      "public": "<instance_ID>.ep11.<region>.hs-crypto.appdomain.cloud",
      "private":"<instance_ID>.ep11.private.<region>.hs-crypto.appdomain.cloud"
    }
  }
  

  Wenn Sie Ihre Instanzen nach dem 12. April 2024 in bestimmten Regionen erstellen, müssen Sie möglicherweise die neuen API-Endpunkte mit dem neuen Format <instance_ID>.ep11.<REGION>.hs-crypto.appdomain.cloud verwenden. Das Verfügbarkeitsdatum variiert je nach Region. Weitere Informationen zu den unterstützten Regionen, den Verfügbarkeitsdaten und den neuen Endpunkt-URLs finden Sie unter Neue Endpunkte.

• Ersetzen Sie <ibm_cloud_apikey> durch den von Ihnen erstellten API-Schlüssel für Service-IDs. Der API-Schlüssel für die Service-ID kann anhand der Anweisungen im Abschnitt API-Schlüssel für Service-ID verwaltenerstellt werden.

Wenn die Beispielanforderung erfolgreich verarbeitet wird, werden Zufallsdaten mit einer Länge von 16 Byte zurückgegeben, wie in ep11.AES_BLOCKSIZEangegeben.

Das vorherige Authentifizierungsbeispiel sowie weitere Golang-Codebeispiele finden Sie unter:

• GREP11-API-Beispiele
• IBM Cloud IAM-Unterstützung für GREP11