Imports System.Net.Http
Imports System.Threading.Tasks
Imports Newtonsoft.Json

Public Class PublicKey
    <JsonProperty("keyId")>
    Public Property KeyId As String

    <JsonProperty("key")>
    Public Property Key As String

    <JsonProperty("exponent")>
    Public Property Exponent As String

    <JsonProperty("modulus")>
    Public Property Modulus As String
End Class

Public Class PanKeyClient
    Private ReadOnly _httpClient As HttpClient
    Private ReadOnly _baseUrl As String = "https://your-api-domain.com"

    Public Sub New()
        _httpClient = New HttpClient()
        _httpClient.BaseAddress = New Uri(_baseUrl)
    End Sub

    Public Async Function GetPanKeyAsync() As Task(Of PublicKey)
        Try
            ' Make the GET request
            Dim response As HttpResponseMessage = Await _httpClient.GetAsync("/v1/rest/keys/pan")

            ' Ensure the request was successful
            response.EnsureSuccessStatusCode()

            ' Read and deserialize the response
            Dim responseBody As String = Await response.Content.ReadAsStringAsync()
            Dim panKey As PublicKey = JsonConvert.DeserializeObject(Of PublicKey)(responseBody)

            Return panKey
        Catch ex As HttpRequestException
            Console.WriteLine($"Request error: {ex.Message}")
            Throw
        End Try
    End Function

    ' Example: Encrypt a bank account number
    Public Function EncryptAccountNumber(accountNumber As String, panKey As PublicKey) As String
        ' Use RSA encryption library to encrypt with the public key
        ' This is a placeholder - implement actual RSA encryption
        ' with PKCS#1 v1.5 padding

        Throw New NotImplementedException("Implement RSA encryption here")
    End Function
End Class

' Example usage:
Dim client As New PanKeyClient()
Dim panKey As PublicKey = Await client.GetPanKeyAsync()

Console.WriteLine($"PAN Key ID: {panKey.KeyId}")

' Encrypt a bank account number for ACH
Dim encryptedAccount As String = client.EncryptAccountNumber("9876543210", panKey)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;

class PublicKey {
    @SerializedName("keyId")
    private String keyId;

    @SerializedName("key")
    private String key;

    @SerializedName("exponent")
    private String exponent;

    @SerializedName("modulus")
    private String modulus;

    // Getters
    public String getKeyId() { return keyId; }
    public String getKey() { return key; }
    public String getExponent() { return exponent; }
    public String getModulus() { return modulus; }
}

public class PanKeyClient {
    private final HttpClient httpClient;
    private final String baseUrl;
    private final Gson gson;

    public PanKeyClient() {
        this.baseUrl = "https://your-api-domain.com";
        this.httpClient = HttpClient.newHttpClient();
        this.gson = new Gson();
    }

    public PublicKey getPanKey() throws Exception {
        // Construct the endpoint URL
        String endpoint = baseUrl + "/v1/rest/keys/pan";

        // Build the HTTP request
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(endpoint))
            .header("Accept", "application/json")
            .GET()
            .build();

        // Send the request and get response
        HttpResponse<String> response = httpClient.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

        // Check response status
        if (response.statusCode() == 200) {
            return gson.fromJson(response.body(), PublicKey.class);
        } else {
            throw new Exception("Request failed with status: " + response.statusCode());
        }
    }

    // Example: Encrypt credit card number
    public String encryptCardNumber(String cardNumber, PublicKey panKey) {
        // Implement RSA encryption with PKCS#1 v1.5 padding
        // using javax.crypto or BouncyCastle library
        throw new UnsupportedOperationException("Implement RSA encryption here");
    }

    // Example usage
    public static void main(String[] args) {
        try {
            PanKeyClient client = new PanKeyClient();
            PublicKey panKey = client.getPanKey();

            System.out.println("PAN Key ID: " + panKey.getKeyId());

            // Encrypt credit card
            String encryptedCard = client.encryptCardNumber("4111111111111111", panKey);
            System.out.println("Encrypted card ready for transmission");
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

require 'net/http'
require 'uri'
require 'json'
require 'openssl'
require 'base64'

class PanKeyClient
  def initialize(base_url = 'https://your-api-domain.com')
    @base_url = base_url
  end

  def get_pan_key
    # Construct the endpoint URL
    uri = URI("#{@base_url}/v1/rest/keys/pan")

    # Create HTTP request
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true if uri.scheme == 'https'
    http.read_timeout = 30

    request = Net::HTTP::Get.new(uri.path)
    request['Accept'] = 'application/json'

    # Send request and handle response
    response = http.request(request)

    case response.code.to_i
    when 200
      JSON.parse(response.body)
    else
      raise "Request failed with status: #{response.code} - #{response.message}"
    end
  rescue StandardError => e
    puts "Request error: #{e.message}"
    raise
  end

  # Example: Encrypt credit card number
  def encrypt_card_number(card_number, pan_key)
    # Import the public key
    public_key_pem = pan_key['key']
    public_key = OpenSSL::PKey::RSA.new(public_key_pem)

    # Encrypt the card number using RSA with PKCS#1 v1.5 padding
    encrypted = public_key.public_encrypt(card_number, OpenSSL::PKey::RSA::PKCS1_PADDING)

    # Return base64 encoded encrypted data
    Base64.strict_encode64(encrypted)
  end
end

# Example usage:
client = PanKeyClient.new
pan_key = client.get_pan_key

puts "PAN Key ID: #{pan_key['keyId']}"

# Encrypt a credit card number
encrypted_card = client.encrypt_card_number('4111111111111111', pan_key)
puts "Encrypted card: #{encrypted_card[0..50]}..."

uri.path)
request['Accept'] = 'application/json'

# Send request and handle response
response = http.request(request)

case response.code.to_i
when 200
JSON.parse(response.body)
else
raise "Request failed with status: #{response.code} - #{response.message}"
end
rescue StandardError => e
puts "Request error: #{e.message}"
raise
end

# Example: Encrypt credit card number
def encrypt_card_number(card_number, pan_key)
# Import the public key
public_key_pem = pan_key['key']
public_key = OpenSSL::PKey::RSA.new(public_key_pem)

# Encrypt the card number using RSA with PKCS#1 v1.5 padding
encrypted = public_key.public_encrypt(card_number, OpenSSL::PKey::RSA::PKCS1_PADDING)

# Return base64 encoded encrypted data
Base64.strict_encode64(encrypted)
end
end

# Example usage:
client = PanKeyClient.new
pan_key = client.get_pan_key

puts "PAN Key ID: #{pan_key['keyId']}"

# Encrypt a credit card number
encrypted_card = client.encrypt_card_number('4111111111111111', pan_key)
puts "Encrypted card: #{encrypted_card[0..50]}..."