Получение IAM-токена для сервисного аккаунта

import time
import jwt

service_account_id = "ajepg0mjt06siua65usm"
key_id = "lfkoe35hsk58aks301nl" # ID ресурса Key, который принадлежит сервисному аккаунту.

with open("private.pem", 'r') as private:
  private_key = private.read() # Чтение закрытого ключа из файла.

now = int(time.time())
payload = {
        'aud': 'https://iam.api.cloud.yandex.net/iam/v1/tokens',
        'iss': service_account_id,
        'iat': now,
        'exp': now + 360}

# Формирование JWT.
encoded_token = jwt.encode(
    payload,
    private_key,
    algorithm='PS256',
    headers={'kid': key_id})

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.bouncycastle.util.io.pem.PemObject;
import org.bouncycastle.util.io.pem.PemReader;

import java.io.FileReader;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.time.Instant;
import java.util.Date;

public class JwtTest {
    public static void main(String[] args) throws Exception {
        PemObject privateKeyPem;
        try (PemReader reader = new PemReader(new FileReader("private.pem"))) {
            privateKeyPem = reader.readPemObject();
        }

        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKeyPem.getContent()));

        String serviceAccountId = "ajepg0mjt06siua65usm";
        String keyId = "lfkoe35hsk58aks301nl";

        Instant now = Instant.now();

        // Формирование JWT.
        String encodedToken = Jwts.builder()
                .setHeaderParam("kid", keyId)
                .setIssuer(serviceAccountId)
                .setAudience("https://iam.api.cloud.yandex.net/iam/v1/tokens")
                .setIssuedAt(Date.from(now))
                .setExpiration(Date.from(now.plusSeconds(360)))
                .signWith(privateKey, SignatureAlgorithm.PS256)
                .compact();
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using Jose;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.OpenSsl;
using Org.BouncyCastle.Security;

class Program
{
    static void Main(string[] args)
    {
        var serviceAccountId = "ajepg0mjt06siua65usm";
        var keyId = "lfkoe35hsk58aks301nl";
        var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();

        var headers = new Dictionary<string, object>()
        {
            { "kid", keyId }
        };

        var payload = new Dictionary<string, object>()
        {
            { "aud", "https://iam.api.cloud.yandex.net/iam/v1/tokens" },
            { "iss", serviceAccountId },
            { "iat", now },
            { "exp", now + 3600 }
        };

        RsaPrivateCrtKeyParameters privateKeyParams;
        using (var pemStream = File.OpenText("private.pem"))
        {
            privateKeyParams = new PemReader(pemStream).ReadObject() as RsaPrivateCrtKeyParameters;
        }

        using (var rsa = new RSACryptoServiceProvider())
        {
            rsa.ImportParameters(DotNetUtilities.ToRSAParameters(privateKeyParams));
            string encodedToken = Jose.JWT.Encode(payload, rsa, JwsAlgorithm.PS256, headers);
        }
    }
}

import (
	"crypto/rsa"
	"io/ioutil"
	"time"

	"github.com/golang-jwt/jwt/v4"
)

const (
	keyID            = "lfkoe35hsk58aks301nl"
	serviceAccountID = "ajepg0mjt06siua65usm"
	keyFile          = "private.pem"
)

// Формирование JWT.
func signedToken() string {
	claims := jwt.RegisteredClaims{
          Issuer:    serviceAccountID,
          ExpiresAt: jwt.NewNumericDate(time.Now().Add(1 * time.Hour)),
          IssuedAt:  jwt.NewNumericDate(time.Now()),
          NotBefore: jwt.NewNumericDate(time.Now()),
          Audience:  []string{"https://iam.api.cloud.yandex.net/iam/v1/tokens"},
	}
	token := jwt.NewWithClaims(jwt.SigningMethodPS256, claims)
	token.Header["kid"] = keyID

	privateKey := loadPrivateKey()
	signed, err := token.SignedString(privateKey)
	if err != nil {
		panic(err)
	}
	return signed
}

func loadPrivateKey() *rsa.PrivateKey {
	data, err := ioutil.ReadFile(keyFile)
	if err != nil {
		panic(err)
	}
	rsaPrivateKey, err := jwt.ParseRSAPrivateKeyFromPEM(data)
	if err != nil {
		panic(err)
	}
	return rsaPrivateKey
}

var jose = require('node-jose');
var fs = require('fs');

var key = fs.readFileSync(require.resolve('private.pem'));

var serviceAccountId = 'ajepg0mjt06siua65usm';
var keyId = 'lfkoe35hsk58aks301nl';
var now = Math.floor(new Date().getTime() / 1000);

var payload = { aud: "https://iam.api.cloud.yandex.net/iam/v1/tokens",
                iss: serviceAccountId,
                iat: now,
                exp: now + 3600 };

jose.JWK.asKey(key, 'pem', { kid: keyId, alg: 'PS256' })
    .then(function(result) {
        jose.JWS.createSign({ format: 'compact' }, result)
            .update(JSON.stringify(payload))
            .final()
            .then(function(result) {
                // result — это сформированный JWT.
            });
    });

use Jose\Component\Core\AlgorithmManager;
use Jose\Component\Core\Converter\StandardConverter;
use Jose\Component\KeyManagement\JWKFactory;
use Jose\Component\Signature\JWSBuilder;
use Jose\Component\Signature\Algorithm\PS256;
use Jose\Component\Signature\Serializer\CompactSerializer;

$service_account_id = 'ajepg0mjt06siua65usm';
$key_id = 'lfkoe35hsk58aks301nl';

$jsonConverter = new StandardConverter();
$algorithmManager = AlgorithmManager::create([
    new PS256()
]);

$jwsBuilder = new JWSBuilder($jsonConverter, $algorithmManager);

$now = time();

$claims = [
    'aud' => 'https://iam.api.cloud.yandex.net/iam/v1/tokens',
    'iss' => $service_account_id,
    'iat' => $now,
    'exp' => $now + 360
];

$header = [
    'alg' => 'PS256',
    'typ' => 'JWT',
    'kid' => $key_id
];

$key = JWKFactory::createFromKeyFile('private.pem');

$payload = $jsonConverter->encode($claims);

// Формирование подписи.
$jws = $jwsBuilder
    ->create()
    ->withPayload($payload)
    ->addSignature($key, $header)
    ->build();

$serializer = new CompactSerializer($jsonConverter);

// Формирование JWT.
$token = $serializer->serialize($jws);

#include <chrono>
#include <fstream>
#include <iterator>

#include "jwt-cpp/jwt.h"

int main(int argc, char *argv[])
{
    std::ifstream priv_key_file("private.pem");
    std::ifstream pub_key_file("public.pem");

    auto now = std::chrono::system_clock::now();
    auto expires_at = now + std::chrono::hours(1);
    auto serviceAccountId = "ajepg0mjt06siua65usm";
    auto keyId = "lfkoe35hsk58aks301nl";
    std::set<std::string> audience;
    audience.insert("https://iam.api.cloud.yandex.net/iam/v1/tokens");
    auto algorithm = jwt::algorithm::ps256(
        std::string(std::istreambuf_iterator<char>{pub_key_file}, {}),
        std::string(std::istreambuf_iterator<char>{priv_key_file}, {}));

    // Формирование JWT.
    auto encoded_token = jwt::create()
        .set_key_id(keyId)
        .set_issuer(serviceAccountId)
        .set_audience(audience)
        .set_issued_at(now)
        .set_expires_at(expires_at)
        .sign(algorithm);
}

require 'jwt'

privateKey = OpenSSL::PKey::RSA.new(File.read('private.pem'))

issuedAt = Time.now.to_i
expirationTime = issuedAt + 360

serviceAccountId = "ajefnghf8o71512u5o8d"

# ID ресурса Key, который принадлежит сервисному аккаунту.
keyId = "ajecsls45da39r33kngg"

headers = { kid: keyId }
payload = {
    typ: 'JWT',
    aud: "https://iam.api.cloud.yandex.net/iam/v1/tokens",
    iss: serviceAccountId,
    iat: issuedAt,
    exp: expirationTime,
    data: 'data' }

# Формирование JWT.
token = JWT.encode(
    payload,
    privateKey,
    'PS256',
    headers)

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"strings"
)

func getIAMToken() string {
	jot := signedToken()
	fmt.Println(jot)
	resp, err := http.Post(
		"https://iam.api.cloud.yandex.net/iam/v1/tokens",
		"application/json",
		strings.NewReader(fmt.Sprintf(`{"jwt":"%s"}`, jot)),
	)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		body, _ := ioutil.ReadAll(resp.Body)
		panic(fmt.Sprintf("%s: %s", resp.Status, body))
	}
	var data struct {
		IAMToken string `json:"iamToken"`
	}
	err = json.NewDecoder(resp.Body).Decode(&data)
	if err != nil {
		panic(err)
	}
	return data.IAMToken
}