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 SadKeyClient
    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 GetSadKeyAsync() As Task(Of PublicKey)
        Try
            ' Make the GET request
            Dim response As HttpResponseMessage = Await _httpClient.GetAsync("/v1/rest/keys/sad")

            ' Ensure the request was successful
            response.EnsureSuccessStatusCode()

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

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

    ' Example: Encrypt a CVV code
    Public Function EncryptCvv(cvv As String, sadKey As PublicKey) As String
        ' Validate CVV format
        If String.IsNullOrEmpty(cvv) OrElse (cvv.Length <> 3 AndAlso cvv.Length <> 4) Then
            Throw New ArgumentException("CVV must be 3 or 4 digits")
        End If

        ' 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 SadKeyClient()
Dim sadKey As PublicKey = Await client.GetSadKeyAsync()

Console.WriteLine($"SAD Key ID: {sadKey.KeyId}")

' Encrypt CVV (never store this - use immediately!)
Dim encryptedCvv As String = client.EncryptCvv("123", sadKey)

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 SadKeyClient {
    private final HttpClient httpClient;
    private final String baseUrl;
    private final Gson gson;

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

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

        // 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 CVV code
    public String encryptCvv(String cvv, PublicKey sadKey) {
        // Validate CVV format
        if (cvv == null || (cvv.length() != 3 && cvv.length() != 4)) {
            throw new IllegalArgumentException("CVV must be 3 or 4 digits");
        }

        // 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 {
            SadKeyClient client = new SadKeyClient();
            PublicKey sadKey = client.getSadKey();

            System.out.println("SAD Key ID: " + sadKey.getKeyId());

            // Encrypt CVV (NEVER store - use immediately!)
            String encryptedCvv = client.encryptCvv("123", sadKey);
            System.out.println("Encrypted CVV ready for immediate transmission");
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

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

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

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

    # 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 CVV code
  def encrypt_cvv(cvv, sad_key)
    # Validate CVV format
    raise ArgumentError, 'CVV must be 3 or 4 digits' unless cvv&.match?(/^\d{3,4}$/)

    # Import the public key
    public_key_pem = sad_key['key']
    public_key = OpenSSL::PKey::RSA.new(public_key_pem)

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

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

# Example usage:
client = SadKeyClient.new
sad_key = client.get_sad_key

puts "SAD Key ID: #{sad_key['keyId']}"

# Encrypt CVV (NEVER store - use immediately in transaction!)
encrypted_cvv = client.encrypt_cvv('123', sad_key)
puts "Encrypted CVV ready for immediate use"

# IMPORTANT: Clear CVV from memory immediately after encryption
cvv = nil
encrypted_cvv = nil  # After sending in transaction