토큰 교환

import requests

def exchange_token(code, code_verifier, client_id, redirect_uri):
  """
  Authorization Code를 Access Token으로 교환합니다 (PKCE).

  Args:
      code: Authorization Code
      code_verifier: PKCE Code Verifier
      client_id: 클라이언트 ID
      redirect_uri: 리다이렉트 URI

  Returns:
      dict: access_token, refresh_token, expires_in 포함
  """
  try:
      response = requests.post(
          'https://oauth.data.hellogsm.kr/v1/oauth/token',
          headers={'Content-Type': 'application/json'},
          json={
              'grant_type': 'authorization_code',
              'code': code,
              'client_id': client_id,
              'redirect_uri': redirect_uri,
              'code_verifier': code_verifier,
          }
      )
      response.raise_for_status()
      return response.json()
  except requests.exceptions.RequestException as e:
      print(f'Error: {e}')
      raise

# 사용 예시 (PKCE)
tokens = exchange_token(
  code='abc123def456',
  code_verifier='dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk',
  client_id='your-client-id',
  redirect_uri='https://your-app.com/callback'
)
print(f'Access Token: {tokens["access_token"]}')
print(f'Refresh Token: {tokens["refresh_token"]}')
print(f'Expires In: {tokens["expires_in"]} seconds')

import java.net.http.*;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;
import java.util.Map;

public class OAuthTokenService {
  private static final HttpClient client = HttpClient.newHttpClient();
  private static final ObjectMapper mapper = new ObjectMapper();

  public static TokenResponse exchangeToken(
      String code,
      String codeVerifier,
      String clientId,
      String redirectUri
  ) throws Exception {
      // 요청 본문 생성
      Map<String, String> requestBody = Map.of(
          "grant_type", "authorization_code",
          "code", code,
          "client_id", clientId,
          "redirect_uri", redirectUri,
          "code_verifier", codeVerifier
      );

      String requestBodyJson = mapper.writeValueAsString(requestBody);

      // HTTP 요청 생성
      HttpRequest request = HttpRequest.newBuilder()
          .uri(URI.create("https://oauth.data.hellogsm.kr/v1/oauth/token"))
          .header("Content-Type", "application/json")
          .POST(HttpRequest.BodyPublishers.ofString(requestBodyJson))
          .build();

      // 요청 전송
      HttpResponse<String> response = client.send(
          request,
          HttpResponse.BodyHandlers.ofString()
      );

      // 응답 처리
      if (response.statusCode() != 200) {
          throw new RuntimeException("Failed to exchange token: " + response.body());
      }

      JsonNode jsonNode = mapper.readTree(response.body());
      return new TokenResponse(
          jsonNode.get("access_token").asText(),
          jsonNode.get("refresh_token").asText(),
          jsonNode.get("expires_in").asInt()
      );
  }

  public static class TokenResponse {
      public final String accessToken;
      public final String refreshToken;
      public final int expiresIn;

      public TokenResponse(String accessToken, String refreshToken, int expiresIn) {
          this.accessToken = accessToken;
          this.refreshToken = refreshToken;
          this.expiresIn = expiresIn;
      }
  }

  public static void main(String[] args) throws Exception {
      String clientId = "your-client-id";
      String codeVerifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"; // authorize/page.mdx에서 저장한 값

      TokenResponse tokens = exchangeToken(
          "abc123def456",
          codeVerifier,
          clientId,
          "https://your-app.com/callback"
      );
      System.out.println("Access Token: " + tokens.accessToken);
      System.out.println("Refresh Token: " + tokens.refreshToken);
      System.out.println("Expires In: " + tokens.expiresIn + " seconds");
  }
}

import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.URI
import com.fasterxml.jackson.annotation.JsonProperty
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.fasterxml.jackson.module.kotlin.readValue

data class TokenRequest(
  val grant_type: String,
  val code: String,
  val client_id: String,
  val redirect_uri: String,
  val code_verifier: String
)

data class TokenResponse(
  @JsonProperty("access_token")
  val accessToken: String,
  @JsonProperty("refresh_token")
  val refreshToken: String,
  @JsonProperty("expires_in")
  val expiresIn: Int
)

class OAuthTokenService {
  private val client = HttpClient.newHttpClient()
  private val mapper = jacksonObjectMapper()

  fun exchangeToken(
      code: String,
      codeVerifier: String,
      clientId: String,
      redirectUri: String
  ): TokenResponse {
      val requestBody = TokenRequest(
          grant_type = "authorization_code",
          code = code,
          client_id = clientId,
          redirect_uri = redirectUri,
          code_verifier = codeVerifier
      )
      val requestBodyJson = mapper.writeValueAsString(requestBody)

      val request = HttpRequest.newBuilder()
          .uri(URI.create("https://oauth.data.hellogsm.kr/v1/oauth/token"))
          .header("Content-Type", "application/json")
          .POST(HttpRequest.BodyPublishers.ofString(requestBodyJson))
          .build()

      val response = client.send(request, HttpResponse.BodyHandlers.ofString())

      if (response.statusCode() != 200) {
          throw RuntimeException("Failed to exchange token: ${response.body()}")
      }

      return mapper.readValue(response.body())
  }
}

// 사용 예시 (PKCE)
fun main() {
  val service = OAuthTokenService()
  val clientId = "your-client-id"
  val codeVerifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk" // authorize/page.mdx에서 저장한 값

  val tokens = service.exchangeToken(
      code = "abc123def456",
      codeVerifier = codeVerifier,
      clientId = clientId,
      redirectUri = "https://your-app.com/callback"
  )

  println("Access Token: ${tokens.accessToken}")
  println("Refresh Token: ${tokens.refreshToken}")
  println("Expires In: ${tokens.expiresIn} seconds")
}