네이버 클라우드 플랫폼의 상품 사용 방법을 보다 상세하게 제공하고, 다양한 API의 활용을 돕기 위해 [설명서][API 참조서]를 구분하여 제공하고 있습니다.

Key Management Service API 참조서 바로가기 >>
Key Management Service 설명서 바로가기 >>

샘플 코드: Best Practice

Key Management Service를 이용하여 '봉투 암호화(Envelope Encryption)'와 '데이터 키 관리' 구현하는 샘플 코드입니다. 봉투 암호화에 대한 설명은 Key Management Service 사용 가이드를 참조하세요. API에 대한 설명은 Key Management Service API 개요를 참조하세요.

시작하기 전에

샘플 코드 참고 주의 사항

본 샘플 코드는 Key Management Service 키를 이용하는데 도움을 드리고자 일반적으로 사용될 수 있는 시나리오를 가정하여 작성된 예시 코드입니다. 여러 시나리오에 완벽하게 대응되는 코드가 아니며, 예외 처리 등의 작업이 미비하기 때문에 실제 사용에 있어 주의가 필요합니다.

API Key 관리 주의 사항

Key Management Service의 암복호화 기능은 Rest API로 이용할 수 있습니다. 이렇게 프로그래밍 방식으로 액세스하는 경우에는 Key Management Service에 직접 액세스를 하지 않고, API Gateway를 통하게 됩니다. API GW는 API Access key를 사용하여 사용자의 자격 증명과 애플리케이션의 자격 증명을 확인합니다. 이에 대한 자세한 설명은 API Gateway를 참조하세요.

API 자격 증명에는 서브 계정의 'access key', 'secret key', 그리고 API의 'api key'를 사용합니다. 서브 계정의 access key, secret key는 Sub Account서브 계정 상세 화면에서 확인할 수 있으며, API의 api key는 API GatewayAPI Keys에서 생성하거나 확인할 수 있습니다.

API 자격 증명에 이용되는 정보를 보유한 사람은 누구든지 Key Management Service 키에 대해 해당 키의 소유자가 보유한 동일한 권한으로 액세스할 수 있습니다. 따라서 Key Management Service 권한을 가진 사용자는 Key Management Service 리소스 사용에 있어서 공유 책임 모델에 부합하는 노력이 필요합니다.

API 자격 증명 정보를 이용함에 있어서 다음을 주의하시기 바랍니다.

  • API 자격 증명 정보(서브 계정의 access key, secret key)는 코드에 직접 포함되어서는 안됩니다.
  • 서비스/애플리케이션마다 다른 자격 증명 정보를 이용해야 합니다.
  • 주기적으로 API 자격 증명 정보를 갱신합니다.
  • 주기적으로 Key Management Service 키 사용 이력을 확인하여 비인가 API 호출 상황을 확인합니다.
  • 사용되지 않은 API 자격 증명 정보는 즉시 폐기합니다.

크리덴셜의 봉투 암호화(Envelope Encryption)

시나리오

당신은 네이버 클라우드 플랫폼을 사용 중인 웹서비스 사의 서버 개발자로서, 웹서버에서 DB 서버에 접속하기 위한 DB 인증 정보를 암호화해야 한다는 아래와 같은 요구사항을 접수했습니다.

  • DB 인증 정보는 암호화되어 보호되어야 함
  • 모든 암호화 키는 표준 권고 수준으로 적절하게 생성/운영/보호되어야 함

이를 위해 DB 인증 정보를 데이터 키로 암호화하고, 데이터 키 역시 다른 키로 암호화하여 보관하기로 했습니다. 데이터 키를 암호화하는 상위 키인 마스터 키를 이용하기 위해 Key Management Service 키 접근 권한을 신청했습니다. 데이터 키를 암호화하고 복호화해야 할 필요가 있기 때문에 Key Management Service 키에 대한 Encryptor/Decryptor 권한을 부여 받은 후, 메일로 전달 받은 Key tag를 확인했습니다.

이미 Sub Account를 통해 알고 있던 자신의 Access key와 Secret key를 다시 확인하기 위해 네이버 클라우드 플랫폼 콘솔의 Sub Account에 접속하여 확인 후 이를 각각 'NCP_ACCESS_KEY', 'NCP_SECRET_KEY'라는 이름으로 환경 변수에 설정했습니다.

또한, Key Management Service API를 직접 호출하기 위해서 API Gateway의 API Keys에서 Key Management Service 전용 API key를 확인했으나 없는 것을 확인하고, 계정 관리자에게 Key Management Service용 API key 생성을 요청했습니다. 계정 관리자로부터 Key Management Service API는 범용 API key를 사용해도 무방하다는 확인을 받은 후, 범용 API key를 자신의 개발 환경 시스템에 'NCP_API_KEY'라는 이름의 환경 변수로 설정했습니다.

데이터 키 역시 암호화 키 생성 기준을 따르고 싶었던 당신은 Key Management Service의 'createCustomKey' API를 통해 복잡한 키 생성 과정을 직접 수행할 필요 없이 high-entropy 키를 생성할 수 있음을 파악했습니다.

DB 인증 정보의 암호화는 AES-CBC를 이용할 것이기 때문에 암복호화에 이용되는 추가 정보인 IV(Initial Vector)값도 함께 관리되어야 합니다. 당신은 DB 인증 정보와 데이터 키, 그리고 추가 암호화 정보를 아래와 같은 '봉투' 형태의 데이터로 관리하기로 했습니다.

{
  "ciphertext": "암호화된 DB 인증 정보",
  "wrappedKey": "암호화된 데이터 암호화 키",
  "iv": "암호화에 사용될 추가 정보(ex. IV값)"
}

이를 생성하는 코드는 아래와 같습니다.

Java 코드

public class EncryptCredential {

  // URI
  private static String KMS_API_BASE_URI = "https://kms.apigw.ntruss.com";

  // END POINT
  private static String KMS_API_DECRYPT = "/keys/v1/%s/decrypt"; // Decryptor 권한 필요
  private static String KMS_API_CUSTOM_KEY = "/keys/v1/%s/createCustomKey"; // Encryptor 권한 필요

  // 샘플용 KEY TAG
  private static String KEY_TAG = "4165867476e68eca06e84c993708c23d22ca2cb6a51ac15750bd7e991ccadc39";

  private static String ncpAccessKey;
  private static String ncpSecretKey;
  private static String ncpApiKey;

  public static void main(String[] args) throws Exception {
    // API 자격 증명 정보를 시스템 환경 변수에 등록하여 사용함
    ncpAccessKey = System.getenv("NCP_ACCESS_KEY");
    ncpSecretKey = System.getenv("NCP_SECRET_KEY");
    ncpApiKey = System.getenv("NCP_API_KEY");

    envelopCredential();
  }

  public static void envelopCredential() throws Exception {
    // 새로운 high-entropy 데이터 키 생성을 요청
    String wrappedDataKey = getCustomKey();
    // 최종적으로 보호하고자하는 기밀 데이터
    String example_credential_json = "{\"AUTH\":\"THIS_IS_A_DB_CREDENTIAL\"}}";

    // 사용자가 보관할 암호화된 데이터 봉투(Envelop encryption 참고)
    String envelope = encrypt(example_credential_json, wrappedDataKey);
    // 본 예제에서는 암호화된 데이터 봉투를 파일에 저장함
    File envelopeFile = new File("credentialEnvelope.json");
    OutputStream os = new BufferedOutputStream(new FileOutputStream(envelopeFile));

    try {
      os.write(envelope.getBytes());
    } finally {
      os.close();
    }
  }

  private static String encrypt(Object obj, String wrappedDataKey) throws Exception {
    Map<String, String> envelope = new HashMap<>();

    // 데이터 키 unwrapping
    String dataKey = unwrapKey(wrappedDataKey);

    // 생성된 high-enrtopy 256 bit의 데이터 키를 AES-CBC 방식으로 암호화
    SecretKey secretKey = new SecretKeySpec(decodeFromBase64(dataKey),"AES");
    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    cipher.init(Cipher.ENCRYPT_MODE, secretKey);
    byte[] iv = cipher.getParameters().getParameterSpec(IvParameterSpec.class).getIV();
    byte[] ciphertext = cipher.doFinal(obj.toString().getBytes());

    envelope.put("wrappedKey", wrappedDataKey);
    envelope.put("ciphertext", encodeToBase64(ciphertext));
    envelope.put("iv", encodeToBase64(iv));

    return JSONValue.toJSONString(envelope);
  }

  private static String unwrapKey(String sealedKey) throws Exception {
    String endPoint = String.format(KMS_API_DECRYPT, KEY_TAG);

    JSONObject data = new JSONObject();
    data.put("ciphertext", sealedKey);
    JSONObject respJsonObject = apiCaller(endPoint, data.toJSONString());
    String plaintext = (respJsonObject.get("plaintext")).toString();
    return plaintext;
  }

  private static String getCustomKey() throws Exception {
    String endPoint = String.format(KMS_API_CUSTOM_KEY, KEY_TAG);

    JSONObject data = new JSONObject();
    data.put("requestPlainKey", false);
    JSONObject respJsonObject = apiCaller(endPoint, data.toJSONString());
    return respJsonObject.get("ciphertext").toString();
  }

  private static JSONObject apiCaller(String endPoint, String data) throws Exception {
    HttpClient client = HttpClients.createDefault();

    long timestamp = System.currentTimeMillis();
    String signature = makeSignature(endPoint, timestamp);
    URIBuilder uriBuilder = new URIBuilder(KMS_API_BASE_URI);
    uriBuilder.setPath(endPoint);

    HttpPost request = new HttpPost(uriBuilder.build().toString());
    request.addHeader("x-ncp-apigw-timestamp", timestamp + "");
    request.addHeader("x-ncp-apigw-api-key", ncpApiKey);
    request.addHeader("x-ncp-iam-access-key", ncpAccessKey);
    request.addHeader("x-ncp-apigw-signature-v1", signature);
    request.addHeader("Content-Type", "application/json");
    request.setEntity(new StringEntity(data));

    HttpResponse response = client.execute(request);
    String responseBody = EntityUtils.toString(response.getEntity());
    JSONParser parser = new JSONParser();
    JSONObject repsObj = (JSONObject) parser.parse(responseBody);
    JSONObject dataObj = (JSONObject) repsObj.get("data");
    return dataObj;
  }

  private static String encodeToBase64(byte[] bytesToEncode) {
    return Base64.getEncoder().encodeToString(bytesToEncode);
  }

  private static byte[] decodeFromBase64(String stringToDecode) {
    return Base64.getDecoder().decode(stringToDecode);
  }

  // API GW 인증용 API 호출 시그니처 생성 (API Gateway 설명서 참조)
  private static String makeSignature(String uri , long timestamp) throws Exception {
    String message = new StringBuilder()
      .append("POST").append(" ").append(uri).append("\n")
      .append(timestamp).append("\n")
      .append(ncpApiKey).append("\n")
      .append(ncpAccessKey)
      .toString();

    SecretKeySpec signingKey = new SecretKeySpec(ncpSecretKey.getBytes("UTF-8"), "HmacSHA256");
    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(signingKey);
    byte[] rawHmac = mac.doFinal(message.getBytes("UTF-8"));
    String encodeBase64String = Base64.getEncoder().encodeToString(rawHmac);
    return encodeBase64String;
  }

}

생성 결과

{
  "ciphertext":"wh6wryZ5MUrzlzd7EW9OYNek+3taxNVnxAcUPBRR6vtDH29tDrFxLyNukqUT3s7i",
  "iv":"HDlrArTVqwHQJRx9IhtqzQ==",
  "wrappedKey":"ncpkms:v1:e0AGESFjKj7xFtCxW1zfGFyZ3G\/4mc51mAMMu1n2hHNLsI4X9h5NKRKx0avz+1ky7\/+7aCd5SAjCOlnV"
}

암호화된 봉투(Envelope)의 사용

시나리오

이제, 위 시나리오를 통해 암호화 처리한 DB 인증 정보가 담긴 '봉투'를 실제 서버 코드에서 이용해야 합니다. 이를 테스트하기 위해 당신은 다음의 코드를 작성했습니다. DB 접속 전 봉투의 암호문을 복호화하여 DB 인증 정보로 변환합니다.

Java 코드

public class ClientApiSample {

  // URI
  private static String KMS_API_BASE_URI = "https://kms.apigw.ntruss.com";

  // END POINT
  private static String KMS_API_DECRYPT = "/keys/v1/%s/decrypt"; // Decryptor 권한 필요

  // KEY TAG
  private static String KEY_TAG = "1bc86ca1be3b062cf8503d0a7e6d3717fe3a1c0480e309b724b26bf961e1f3c6";

  private static String ncpAccessKey;
  private static String ncpSecretKey;
  private static String ncpApiKey;

  public static void main(String[] args) throws Exception {
    // API 자격 증명 정보를 시스템 환경 변수에 등록하여 사용함
    ncpAccessKey = System.getenv("NCP_ACCESS_KEY");
    ncpSecretKey = System.getenv("NCP_SECRET_KEY");
    ncpApiKey = System.getenv("NCP_API_KEY");

    String dbCredential = getCredential();
  }

  public static String getCredential() throws Exception {
    // 사용자가 보관할 암호화된 데이터 봉투(Envelop encryption 참고)
    File envelopeFile = new File("credentialEnvelope.json");
    InputStream is = new BufferedInputStream(new FileInputStream(envelopeFile));

    String envelope = new String(Files.readAllBytes(Paths.get("credentialEnvelope.json")));
    JSONParser parser = new JSONParser();
    JSONObject envelopeJson = (JSONObject) parser.parse(envelope);
    String wrappedDataKey = envelopeJson.get("wrappedKey").toString();
    String ciphertext = envelopeJson.get("ciphertext").toString();
    String iv = envelopeJson.get("iv").toString();

    return decrypt(ciphertext, wrappedDataKey, iv);
  }

  private static String decrypt(String ciphertext, String wrappedDataKey, String iv) throws Exception {

    String dataKey = unwrapKey(wrappedDataKey);
    IvParameterSpec ivParameterSpec = new IvParameterSpec(decodeFromBase64(iv));
    SecretKey secretKey = new SecretKeySpec(decodeFromBase64(dataKey), "AES");
    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec);
    byte[] plaintext = cipher.doFinal(decodeFromBase64(ciphertext));

    return new String(plaintext);
  }

  private static String unwrapKey(String sealedKey) throws Exception {
    String endPoint = String.format(KMS_API_DECRYPT, KEY_TAG);

    JSONObject data = new JSONObject();
    data.put("ciphertext", sealedKey);
    JSONObject respJsonObject = apiCaller(endPoint, data.toJSONString());
    String plaintext = (respJsonObject.get("plaintext")).toString();
    return plaintext;
  }

  private static JSONObject apiCaller(String endPoint, String data) throws Exception {
    HttpClient client = HttpClients.createDefault();

    long timestamp = System.currentTimeMillis();
    String signature = makeSignature(endPoint, timestamp);
    URIBuilder uriBuilder = new URIBuilder(KMS_API_BASE_URI);
    uriBuilder.setPath(endPoint);

    HttpPost request = new HttpPost(uriBuilder.build().toString());
    request.addHeader("x-ncp-apigw-timestamp", timestamp + "");
    request.addHeader("x-ncp-apigw-api-key", ncpApiKey);
    request.addHeader("x-ncp-iam-access-key", ncpAccessKey);
    request.addHeader("x-ncp-apigw-signature-v1", signature);
    request.addHeader("Content-Type", "application/json");
    request.setEntity(new StringEntity(data));

    HttpResponse response = client.execute(request);
    String responseBody = EntityUtils.toString(response.getEntity());
    JSONParser parser = new JSONParser();
    JSONObject repsObj = (JSONObject) parser.parse(responseBody);
    JSONObject dataObj = (JSONObject) repsObj.get("data");
    return dataObj;
  }

  private static byte[] decodeFromBase64(String stringToDecode) {
    return Base64.getDecoder().decode(stringToDecode);
  }

  // API GW 인증용 API 호출 시그니처 생성 (API Gateway 설명서 참조)
  private static String makeSignature(String uri , long timestamp) throws Exception {
    String message = new StringBuilder()
      .append("POST").append(" ").append(uri).append("\n")
      .append(timestamp).append("\n")
      .append(ncpApiKey).append("\n")
      .append(ncpAccessKey)
      .toString();

    SecretKeySpec signingKey = new SecretKeySpec(ncpSecretKey.getBytes("UTF-8"), "HmacSHA256");
    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(signingKey);
    byte[] rawHmac = mac.doFinal(message.getBytes("UTF-8"));
    String encodeBase64String = Base64.getEncoder().encodeToString(rawHmac);
    return encodeBase64String;
  }

}

데이터 키 관리

시나리오

위와 같이 크리덴셜과 데이터 키를 암호화하여 함께 묶어 보관하는 방식은 데이터 보호에 있어 가장 안전하다고 알려진 방식입니다. 하지만, 이것이 전부가 아닙니다. 모든 암호화 키는 알려진 암호학적 취약점들에 대비하여 주기적으로 회전(갱신)될 필요가 있습니다.

당신이 위 예제를 통해 KEY_TAG로 이용하던 마스터 키는 필수적으로 일정 주기마다(최대 365일) 자동으로 회전되도록 설정되어 있습니다. 뿐만 아니라, Key Management Service 관리자(또는 키 관리자)에 의해 수동으로 회전될 수도 있습니다.

당신이 DB 인증 정보의 암호화에 직접 이용하던 데이터 키는 마스터 키로 암호화되어 있기 때문에, 마스터 키의 회전 설정에 의해 마찬가지로 회전되어 저장되는 효과와 동일하다고 볼 수 있습니다. 단, 마스터 키가 회전되면 회전되기 이전의 마스터 키로 암호화되어 있는 당신의 데이터 키 역시 새로 회전된 마스터 키로 재암호화(reencrypt)해야 합니다. Key Management Service의 'reencrypt' API를 통해 간편하게 재암호화를 수행할 수 있습니다. 'reencrypt' API는 가장 최신 버전의 키로 기존 암호문을 재암호화합니다.

당신은 키 사용 권한이 할당될 때 메일을 통해 알림을 받을 것처럼, 키가 회전되면 이에 대한 알림도 받을 것입니다. 알림을 받으면 가능한 빠른 시일내에 재암호화를 수행해야 합니다. 이를 위해 당신은 키 회전 알림을 받으면 수행할 코드를 아래와 같이 작성했습니다. 이제, 데이터 키는 회전된 새 버전으로 재암호화되어 새로운 봉투를 생성합니다.(봉투의 분실은 곧 데이터의 분실입니다. 따라서, 새로 생성된 봉투는 직접 확인한 후에 이전 봉투를 삭제하는 것이 안전합니다. 이를 위해 기존의 봉투를 덮어쓰지 않고, 새로운 봉투를 생성합니다.)

Java 코드

public class ClientApiSample {

  // URI
  private static String KMS_API_BASE_URI = "https://kms.apigw.ntruss.com";

  // END POINT
  private static String KMS_API_REENCRYPT = "/keys/v1/%s/reencrypt";

  // KEY TAG
  private static String KEY_TAG = "1bc86ca1be3b062cf8503d0a7e6d3717fe3a1c0480e309b724b26bf961e1f3c6";

  private static String ncpAccessKey;
  private static String ncpSecretKey;
  private static String ncpApiKey;

  public static void main(String[] args) throws Exception {
    ncpAccessKey = System.getenv("NCP_ACCESS_KEY");
    ncpSecretKey = System.getenv("NCP_SECRET_KEY");
    ncpApiKey = System.getenv("NCP_API_KEY");

    reenvelopCredential();
  }

  private static void reenvelopCredential() throws Exception {
    String envelope = new String(Files.readAllBytes(Paths.get("credentialEnvelope.json")));
    JSONParser parser = new JSONParser();
    JSONObject envelopeJson = (JSONObject) parser.parse(envelope);
    String wrappedDataKey = envelopeJson.get("wrappedKey").toString();
    String ciphertext = envelopeJson.get("ciphertext").toString();
    String iv = envelopeJson.get("iv").toString();

    // 암호화된 데이터키를 최신 버전으로 재암호화
    String rewrappedDataKey = rewrapKey(wrappedDataKey);

    Map<String, String> newEnvelope = new HashMap<>();
    // 암호문과 iv는 그대로, 재암호화된 키만 변경하면 됨
    newEnvelope.put("wrappedKey", rewrappedDataKey);
    newEnvelope.put("ciphertext", ciphertext);
    newEnvelope.put("iv", iv);

    String newEnvelopeJson = JSONValue.toJSONString(newEnvelope);

    // 새로운 봉투를 생성 (확인 후에 기존 봉투 제거 필요)
    File newEnvelopeFile = new File("credentialEnvelope_new.json");
    OutputStream os = new BufferedOutputStream(new FileOutputStream(newEnvelopeFile));

    try {
      os.write(newEnvelopeJson.getBytes());
    } finally {
      os.close();
    }
  }

  private static String rewrapKey(String wrappedDataKey) throws Exception {
    String endPoint = String.format(KMS_API_REENCRYPT, KEY_TAG);

    JSONObject data = new JSONObject();
    data.put("ciphertext", wrappedDataKey);

    JSONObject respJsonObject = apiCaller(endPoint, data.toJSONString());
    String ciphertext = respJsonObject.get("newCiphertext").toString();
    return ciphertext;
  }

  private static JSONObject apiCaller(String endPoint, String data) throws Exception {
    HttpClient client = HttpClients.createDefault();

    long timestamp = System.currentTimeMillis();
    String signature = makeSignature(endPoint, timestamp);
    URIBuilder uriBuilder = new URIBuilder(KMS_API_BASE_URI);
    uriBuilder.setPath(endPoint);

    HttpPost request = new HttpPost(uriBuilder.build().toString());
    request.addHeader("x-ncp-apigw-timestamp", timestamp + "");
    request.addHeader("x-ncp-apigw-api-key", ncpApiKey);
    request.addHeader("x-ncp-iam-access-key", ncpAccessKey);
    request.addHeader("x-ncp-apigw-signature-v1", signature);
    request.addHeader("Content-Type", "application/json");
    request.setEntity(new StringEntity(data));

    HttpResponse response = client.execute(request);
    String responseBody = EntityUtils.toString(response.getEntity());
    JSONParser parser = new JSONParser();
    JSONObject repsObj = (JSONObject) parser.parse(responseBody);
    JSONObject dataObj = (JSONObject) repsObj.get("data");
    return dataObj;
  }

  private static String makeSignature(String uri , long timestamp) throws Exception {
    String message = new StringBuilder()
      .append("POST").append(" ").append(uri).append("\n")
      .append(timestamp).append("\n")
      .append(ncpApiKey).append("\n")
      .append(ncpAccessKey)
      .toString();

    SecretKeySpec signingKey = new SecretKeySpec(ncpSecretKey.getBytes("UTF-8"), "HmacSHA256");
    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(signingKey);
    byte[] rawHmac = mac.doFinal(message.getBytes("UTF-8"));
    String encodeBase64String = Base64.getEncoder().encodeToString(rawHmac);
    return encodeBase64String;
  }
}

생성 결과

{
  "ciphertext":"wh6wryZ5MUrzlzd7EW9OYNek+3taxNVnxAcUPBRR6vtDH29tDrFxLyNukqUT3s7i",
  "iv":"HDlrArTVqwHQJRx9IhtqzQ==",
  "wrappedKey":"ncpkms:v2:lNZubJHJ4coJConKPBf4gYghFN0h\/rjHmOBtvVbTXmXynRcKhPxPNrjkCTgurBZ4a7Fb7+\/8dVKcC33R"
}

Java Client SDK

Key Management Service Rest API는 Java SDK(Maven project)를 제공하고 있습니다. 이 SDK를 이용하면 간편하게 API Gateway를 통해 Key Management Service API를 호출할 수 있습니다.

[Key Management Service Java Client SDK 다운로드]

연결 준비

모든 요청은 ApiClient객체를 통해 호출됩니다. ApiClient 객체는 인증 정보를 설정하여 생성합니다.

인증 정보 설정

Key Management Service API는 API Gateway를 통해 호출되며, API Gateway에 등록된 API Key 인증과, Sub Accounts(IAM) 인증을 수행합니다. 이 정보는 PropertiesFileCredentialsProvider 객체를 이용해 설정할 수 있습니다.

type=iam
apiKey="API Gateway에 설정된 API Key"
accessKey="Sub Account에 설정된 서브계정의 Access Key"
secretKey="Sub Account에 설정된 서브계정의 Secret Key"

위 내용을 credentials.properties라는 이름의 인증 정보 파일을 생성하도록 합니다. 이 파일은 유출되지 않도록 적절한 보호와 접근제어가 필요합니다.

클라이언트 객체 설정

아래와 같이 미리 정의된 형태의 빌더로 ApiClient 객체를 생성활 수 있습니다.

public void setUp() {
  apiClient = new ApiClient.ApiClientBuilder()
    .addMarshaller(JsonMarshaller.getInstance())
    .addMarshaller(XmlMarshaller.getInstance())
    .addMarshaller(FormMarshaller.getInstance())
    .setCredentials(new PropertiesFileCredentialsProvider("credentials.properties").getCredentials()) // 인증 정보 설정
    .setLogging(true)
    .build();

  api = new V1Api(apiClient);
}

API 호출

각각의 Key Management Service API에 대한 메서드가 제공됩니다. Key Management Service API를 요청하기 위해서는 올바른 파라미터를 전달해야 합니다. keyTag는 공통으로 전달되는 파라미터이며, 요청 body는 각 API별로 클래스화되어 있습니다. 호출하고자 하는 API에 맞는 body 객체를 생성한 후, 파라미터를 설정하시기 바랍니다. 파라미터에 대한 자세한 안내는 Key Management Service Rest API Reference를 참고하세요.

Encrypt: keyTagEncryptPost(String keyTag, EncryptRequestBody body)

예제
public void keyTagEncryptPostTest() throws ApiException, SdkException {
    String keyTag = "53fdfdc1d875625d9cffc317e9c729c1febc5849328eb15b7b75ba17eb17e70c";
    EncryptRequestBody body = new EncryptRequestBody();
    String plaintext = Base64.getEncoder().encodeToString("This is a test.".getBytes());
    body.setPlaintext(plaintext);

    try {
        api.keyTagEncryptPost(keyTag, body);
        // Handler Successful response
    } catch (ApiException e) {
        // Handler Failed response
        e.printStackTrace();
    } catch (SdkException e) {
        // Handle exceptions that occurred before communication with the server
        e.printStackTrace();
    }
}

Decrypt: keyTagDecryptPost(String keyTag, DecryptRequestBody body)

예제
public void keyTagDecryptPostTest() throws ApiException, SdkException {
    String keyTag = "53fdfdc1d875625d9cffc317e9c729c1febc5849328eb15b7b75ba17eb17e70c";
    DecryptRequestBody body = new DecryptRequestBody();
    String ciphertext = "ncpkms:v1:eEEYwgBf/HGmqUEbTV/rASoJjneBjII+dOTnFYVOlvTnyw/+SFjwvjHpUg==";
    body.setCiphertext(ciphertext);

    try {
        api.keyTagDecryptPost(keyTag, body);
        // Handler Successful response
    } catch (ApiException e) {
        // Handler Failed response
        e.printStackTrace();
    } catch (SdkException e) {
        // Handle exceptions that occurred before communication with the server
        e.printStackTrace();
    }
}

Create user custom key: keyTagCreateCustomKeyPost(String keyTag, CreateCustomKeyRequestBody body)

예제
public void keyTagCreateCustomKeyPostTest() throws ApiException, SdkException {
    String keyTag = "53fdfdc1d875625d9cffc317e9c729c1febc5849328eb15b7b75ba17eb17e70c";
    CreateCustomKeyRequestBody body = new CreateCustomKeyRequestBody();
    body.setRequestPlainKey(true); // Required parameter
    body.setBits(512); // Optional parameter

    try {
        api.keyTagCreateCustomKeyPost(keyTag, body);
        // Handler Successful response
    } catch (ApiException e) {
        // Handler Failed response
        e.printStackTrace();
    } catch (SdkException e) {
        // Handle exceptions that occurred before communication with the server
        e.printStackTrace();
    }
}

Re-encrypt: keyTagReencryptPost(String keyTag, ReencryptRequestBody body)

예제
public void keyTagReencryptPostTest() throws ApiException, SdkException {
    String keyTag = "53fdfdc1d875625d9cffc317e9c729c1febc5849328eb15b7b75ba17eb17e70c";
    ReencryptRequestBody body = new ReencryptRequestBody();
    String ciphertext = "ncpkms:v1:eEEYwgBf/HGmqUEbTV/rASoJjneBjII+dOTnFYVOlvTnyw/+SFjwvjHpUg==";
    body.setCiphertext(ciphertext);

    try {
        api.keyTagReencryptPost(keyTag, body);
        // Handler Successful response
    } catch (ApiException e) {
        // Handler Failed response
        e.printStackTrace();
    } catch (SdkException e) {
        // Handle exceptions that occurred before communication with the server
        e.printStackTrace();
    }
}

Sign: keyTagSignPost(String keyTag, SignRequestBody body)

예제
public void keyTagSignPostTest() throws ApiException, SdkException {
    String keyTag = "4f81e47fae0a28dd50b9e5e0c3a204e371afa6d35b78b81cf802b80a2aa780ab";
    SignRequestBody body = new SignRequestBody();
    String data = "Test message";
    body.setData(Base64.getEncoder().encodeToString(data.getBytes()));

    try {
        api.keyTagSignPost(keyTag, body);
        // Handler Successful response
    } catch (ApiException e) {
        // Handler Failed response
        e.printStackTrace();
    } catch (SdkException e) {
        // Handle exceptions that occurred before communication with the server
        e.printStackTrace();
    }
}

Verify: keyTagVerifyPost(String keyTag, VerifyRequestBody body)

예제
public void keyTagVerifyPostTest() throws ApiException, SdkException {
    String keyTag = "4f81e47fae0a28dd50b9e5e0c3a204e371afa6d35b78b81cf802b80a2aa780ab";
    VerifyRequestBody body = new VerifyRequestBody();
    String data = "Test message";
    body.setData(Base64.getEncoder().encodeToString(data.getBytes()));
    body.setSignature("ncpkms:v1:MEUCIQDkn9k3voN2ABewgCAortmV4HVDXSok9bS+DX+GDd1hzAIgcIndWRNmx5j9zjMoDk9NYF3M5kk+KvRyYBVXGREVx1E=");

    try {
        api.keyTagVerifyPost(keyTag, body);
        // Handler Successful response
    } catch (ApiException e) {
        // Handler Failed response
        e.printStackTrace();
    } catch (SdkException e) {
        // Handle exceptions that occurred before communication with the server
        e.printStackTrace();
    }
}

연관 정보

""에 대한 건이 검색되었습니다.

    ""에 대한 검색 결과가 없습니다.

    처리중...