qsafe-sdk 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8615d05737d2c7cad17ff224f13903d8846f7211670509790471db46dfdd7129
+  data.tar.gz: 60cef2102af8ca6c4a38fd66a403a0e6ec3459a61a4de61e32fc5e38913a09d6
+SHA512:
+  metadata.gz: 0045faf810f273f2c8cc9a827911981fa1d8f948eda8fae360a12d87f0653d1507160ddc1d36efa90b89959a0151a75552c259174cb3dbac62e9bf6dcf98c207
+  data.tar.gz: c310c740299c41070c1f6b0e3c0a16c3285315109fe51bff00eb3c734be8676d24aa11afb11e16f04ffe1f420653d81559576eec12be475e6e1477786b83461d

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'rake', '~> 13.0.1'
+  gem 'pry-byebug'
+  gem 'rubocop', '~> 0.66.0'
+end

data/README.md

@@ -0,0 +1,134 @@
+# qsafe-sdk for Ruby
+
+Post-quantum cryptography SDK for the [QSafe API](https://rushikesh66-pqc-api.hf.space) — supports ML-KEM (Kyber) encryption and ML-DSA (Dilithium) signatures.
+
+- API version: 1.0.0
+- Ruby: 2.7+
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'qsafe-sdk', '~> 1.0'
+```
+
+Then run:
+
+```sh
+bundle install
+```
+
+Or install directly:
+
+```sh
+gem install qsafe-sdk
+```
+
+## Authentication
+
+| Method | Use case | How to set |
+|--------|----------|------------|
+| **API Key** | Programmatic access (recommended) | `config.api_key['ApiKeyHeader'] = 'pqc_your_key'` |
+| **JWT Bearer** | Managing API keys, user sessions | `config.access_token = 'your_jwt_token'` |
+
+> **Getting an API key:** Register → Login (JWT) → `POST /api-keys` → copy `data.api_key`.
+
+## Quick Start — API Key Auth (Recommended)
+
+```ruby
+require 'qsafe_sdk'
+
+# Configure API key
+QSafe.configure do |config|
+  config.api_key['ApiKeyHeader'] = 'pqc_your_api_key_here'
+end
+
+keypairs_api = QSafe::KeypairsApi.new
+crypto_api = QSafe::CryptographicOperationsApi.new
+
+# 1. Generate a KEM keypair
+kp = keypairs_api.generate_keypair(QSafe::GenerateKeypairRequest.new(algorithm: 'KYBER768'))
+keypair_id = kp.data.id
+puts "Keypair: #{keypair_id}"
+
+# 2. Encrypt
+enc = crypto_api.encrypt_data(keypair_id, QSafe::EncryptRequest.new(plaintext: 'Hello, quantum-safe world!'))
+ciphertext = enc.data.ciphertext
+encapsulated_key = enc.data.encapsulated_key
+
+# 3. Decrypt
+dec = crypto_api.decrypt_data(keypair_id, QSafe::DecryptRequest.new(
+  ciphertext: ciphertext,
+  encapsulated_key: encapsulated_key
+))
+puts "Decrypted: #{dec.data.plaintext}"
+```
+
+### Sign & Verify
+
+```ruby
+# Generate signature keypair
+kp = keypairs_api.generate_keypair(QSafe::GenerateKeypairRequest.new(algorithm: 'DILITHIUM3'))
+keypair_id = kp.data.id
+
+# Sign
+sig = crypto_api.sign_data(keypair_id, QSafe::SignRequest.new(
+  message: 'I approve this transaction',
+  hash_algorithm: 'sha256'
+))
+signature = sig.data.signature
+
+# Verify
+ver = crypto_api.verify_signature(keypair_id, QSafe::VerifyRequest.new(
+  message: 'I approve this transaction',
+  signature: signature,
+  hash_algorithm: 'sha256'
+))
+puts "Valid: #{ver.data.verification_result.valid}"
+```
+
+## Quick Start — JWT Auth (for managing API keys)
+
+```ruby
+require 'qsafe_sdk'
+
+auth_api = QSafe::AuthenticationApi.new
+
+# Register
+reg = auth_api.register_user(QSafe::RegisterRequest.new(
+  email: 'you@example.com',
+  password: 'SecureP@ssw0rd123',
+  first_name: 'Your',
+  last_name: 'Name'
+))
+jwt_token = reg.data.access_token
+
+# Use JWT to create an API key
+QSafe.configure { |c| c.access_token = jwt_token }
+keys_api = QSafe::APIKeysApi.new
+key_resp = keys_api.create_api_key(QSafe::CreateApiKeyRequest.new(
+  name: 'My Production Key',
+  permissions: %w[read write crypto_encrypt crypto_decrypt crypto_sign crypto_verify]
+))
+raw_api_key = key_resp.data.api_key  # pqc_xxxx — save this!
+puts "API Key: #{raw_api_key}"
+```
+
+## API Reference
+
+| Method | Endpoint | Auth |
+|--------|----------|------|
+| `AuthenticationApi#register_user` | POST /auth/register | None |
+| `AuthenticationApi#login_user` | POST /auth/login | None |
+| `APIKeysApi#create_api_key` | POST /api-keys | **JWT only** |
+| `KeypairsApi#generate_keypair` | POST /generate-keypair | JWT or API key |
+| `CryptographicOperationsApi#encrypt_data` | POST /keypairs/{id}/encrypt | JWT or API key |
+| `CryptographicOperationsApi#decrypt_data` | POST /keypairs/{id}/decrypt | JWT or API key |
+| `CryptographicOperationsApi#sign_data` | POST /keypairs/{id}/sign | JWT or API key |
+| `CryptographicOperationsApi#verify_signature` | POST /keypairs/{id}/verify | JWT or API key |
+
+## Support
+
+- API docs: https://rushikesh66-pqc-api.hf.space/api-docs
+- Issues: https://github.com/rushikesh-kakadiya/QSafeApi/issues

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+  task default: :spec
+rescue LoadError
+  # no rspec available
+end

data/docs/APIKeysApi.md

@@ -0,0 +1,427 @@
+# QSafe::APIKeysApi
+
+All URIs are relative to *https://rushikesh66-pqc-api.hf.space*
+
+| Method | HTTP request | Description |
+| ------ | ------------ | ----------- |
+| [**create_api_key**](APIKeysApi.md#create_api_key) | **POST** /api-keys | Create API key (JWT only) |
+| [**get_api_key**](APIKeysApi.md#get_api_key) | **GET** /api-keys/{keyId} | Get API key details (JWT only) |
+| [**get_api_key_usage**](APIKeysApi.md#get_api_key_usage) | **GET** /api-keys/{keyId}/usage | Get API key usage stats (JWT only) |
+| [**list_api_keys**](APIKeysApi.md#list_api_keys) | **GET** /api-keys | List API keys (JWT only) |
+| [**rotate_api_key**](APIKeysApi.md#rotate_api_key) | **POST** /api-keys/{keyId}/rotate | Rotate API key — generates new key value (JWT only) |
+| [**update_api_key**](APIKeysApi.md#update_api_key) | **PATCH** /api-keys/{keyId} | Update API key (JWT only) |
+
+
+## create_api_key
+
+> <CreateApiKey201Response> create_api_key(create_api_key_request)
+
+Create API key (JWT only)
+
+### Examples
+
+```ruby
+require 'time'
+require 'qsafe-sdk'
+# setup authorization
+QSafe.configure do |config|
+  # Configure Bearer authorization (JWT): BearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = QSafe::APIKeysApi.new
+create_api_key_request = QSafe::CreateApiKeyRequest.new({name: 'Production API Key'}) # CreateApiKeyRequest | 
+
+begin
+  # Create API key (JWT only)
+  result = api_instance.create_api_key(create_api_key_request)
+  p result
+rescue QSafe::ApiError => e
+  puts "Error when calling APIKeysApi->create_api_key: #{e}"
+end
+```
+
+#### Using the create_api_key_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<CreateApiKey201Response>, Integer, Hash)> create_api_key_with_http_info(create_api_key_request)
+
+```ruby
+begin
+  # Create API key (JWT only)
+  data, status_code, headers = api_instance.create_api_key_with_http_info(create_api_key_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <CreateApiKey201Response>
+rescue QSafe::ApiError => e
+  puts "Error when calling APIKeysApi->create_api_key_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **create_api_key_request** | [**CreateApiKeyRequest**](CreateApiKeyRequest.md) |  |  |
+
+### Return type
+
+[**CreateApiKey201Response**](CreateApiKey201Response.md)
+
+### Authorization
+
+[BearerAuth](../README.md#BearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## get_api_key
+
+> <GetApiKey200Response> get_api_key(key_id)
+
+Get API key details (JWT only)
+
+### Examples
+
+```ruby
+require 'time'
+require 'qsafe-sdk'
+# setup authorization
+QSafe.configure do |config|
+  # Configure Bearer authorization (JWT): BearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = QSafe::APIKeysApi.new
+key_id = 'ak_1234567890' # String | API key identifier
+
+begin
+  # Get API key details (JWT only)
+  result = api_instance.get_api_key(key_id)
+  p result
+rescue QSafe::ApiError => e
+  puts "Error when calling APIKeysApi->get_api_key: #{e}"
+end
+```
+
+#### Using the get_api_key_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetApiKey200Response>, Integer, Hash)> get_api_key_with_http_info(key_id)
+
+```ruby
+begin
+  # Get API key details (JWT only)
+  data, status_code, headers = api_instance.get_api_key_with_http_info(key_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetApiKey200Response>
+rescue QSafe::ApiError => e
+  puts "Error when calling APIKeysApi->get_api_key_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **key_id** | **String** | API key identifier |  |
+
+### Return type
+
+[**GetApiKey200Response**](GetApiKey200Response.md)
+
+### Authorization
+
+[BearerAuth](../README.md#BearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_api_key_usage
+
+> <GetApiKeyUsage200Response> get_api_key_usage(key_id, opts)
+
+Get API key usage stats (JWT only)
+
+### Examples
+
+```ruby
+require 'time'
+require 'qsafe-sdk'
+# setup authorization
+QSafe.configure do |config|
+  # Configure Bearer authorization (JWT): BearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = QSafe::APIKeysApi.new
+key_id = 'ak_1234567890' # String | API key identifier
+opts = {
+  time_range: '1h' # String | 
+}
+
+begin
+  # Get API key usage stats (JWT only)
+  result = api_instance.get_api_key_usage(key_id, opts)
+  p result
+rescue QSafe::ApiError => e
+  puts "Error when calling APIKeysApi->get_api_key_usage: #{e}"
+end
+```
+
+#### Using the get_api_key_usage_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetApiKeyUsage200Response>, Integer, Hash)> get_api_key_usage_with_http_info(key_id, opts)
+
+```ruby
+begin
+  # Get API key usage stats (JWT only)
+  data, status_code, headers = api_instance.get_api_key_usage_with_http_info(key_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetApiKeyUsage200Response>
+rescue QSafe::ApiError => e
+  puts "Error when calling APIKeysApi->get_api_key_usage_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **key_id** | **String** | API key identifier |  |
+| **time_range** | **String** |  | [optional][default to &#39;24h&#39;] |
+
+### Return type
+
+[**GetApiKeyUsage200Response**](GetApiKeyUsage200Response.md)
+
+### Authorization
+
+[BearerAuth](../README.md#BearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## list_api_keys
+
+> <ListApiKeys200Response> list_api_keys(opts)
+
+List API keys (JWT only)
+
+### Examples
+
+```ruby
+require 'time'
+require 'qsafe-sdk'
+# setup authorization
+QSafe.configure do |config|
+  # Configure Bearer authorization (JWT): BearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = QSafe::APIKeysApi.new
+opts = {
+  page: 1, # Integer | 
+  limit: 10, # Integer | 
+  status: 'active' # String | 
+}
+
+begin
+  # List API keys (JWT only)
+  result = api_instance.list_api_keys(opts)
+  p result
+rescue QSafe::ApiError => e
+  puts "Error when calling APIKeysApi->list_api_keys: #{e}"
+end
+```
+
+#### Using the list_api_keys_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ListApiKeys200Response>, Integer, Hash)> list_api_keys_with_http_info(opts)
+
+```ruby
+begin
+  # List API keys (JWT only)
+  data, status_code, headers = api_instance.list_api_keys_with_http_info(opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ListApiKeys200Response>
+rescue QSafe::ApiError => e
+  puts "Error when calling APIKeysApi->list_api_keys_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **page** | **Integer** |  | [optional][default to 1] |
+| **limit** | **Integer** |  | [optional][default to 10] |
+| **status** | **String** |  | [optional] |
+
+### Return type
+
+[**ListApiKeys200Response**](ListApiKeys200Response.md)
+
+### Authorization
+
+[BearerAuth](../README.md#BearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## rotate_api_key
+
+> <RotateApiKey200Response> rotate_api_key(key_id)
+
+Rotate API key — generates new key value (JWT only)
+
+### Examples
+
+```ruby
+require 'time'
+require 'qsafe-sdk'
+# setup authorization
+QSafe.configure do |config|
+  # Configure Bearer authorization (JWT): BearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = QSafe::APIKeysApi.new
+key_id = 'ak_1234567890' # String | API key identifier
+
+begin
+  # Rotate API key — generates new key value (JWT only)
+  result = api_instance.rotate_api_key(key_id)
+  p result
+rescue QSafe::ApiError => e
+  puts "Error when calling APIKeysApi->rotate_api_key: #{e}"
+end
+```
+
+#### Using the rotate_api_key_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<RotateApiKey200Response>, Integer, Hash)> rotate_api_key_with_http_info(key_id)
+
+```ruby
+begin
+  # Rotate API key — generates new key value (JWT only)
+  data, status_code, headers = api_instance.rotate_api_key_with_http_info(key_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <RotateApiKey200Response>
+rescue QSafe::ApiError => e
+  puts "Error when calling APIKeysApi->rotate_api_key_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **key_id** | **String** | API key identifier |  |
+
+### Return type
+
+[**RotateApiKey200Response**](RotateApiKey200Response.md)
+
+### Authorization
+
+[BearerAuth](../README.md#BearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## update_api_key
+
+> <GetApiKey200Response> update_api_key(key_id, update_api_key_request)
+
+Update API key (JWT only)
+
+### Examples
+
+```ruby
+require 'time'
+require 'qsafe-sdk'
+# setup authorization
+QSafe.configure do |config|
+  # Configure Bearer authorization (JWT): BearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = QSafe::APIKeysApi.new
+key_id = 'ak_1234567890' # String | API key identifier
+update_api_key_request = QSafe::UpdateApiKeyRequest.new # UpdateApiKeyRequest | 
+
+begin
+  # Update API key (JWT only)
+  result = api_instance.update_api_key(key_id, update_api_key_request)
+  p result
+rescue QSafe::ApiError => e
+  puts "Error when calling APIKeysApi->update_api_key: #{e}"
+end
+```
+
+#### Using the update_api_key_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetApiKey200Response>, Integer, Hash)> update_api_key_with_http_info(key_id, update_api_key_request)
+
+```ruby
+begin
+  # Update API key (JWT only)
+  data, status_code, headers = api_instance.update_api_key_with_http_info(key_id, update_api_key_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetApiKey200Response>
+rescue QSafe::ApiError => e
+  puts "Error when calling APIKeysApi->update_api_key_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **key_id** | **String** | API key identifier |  |
+| **update_api_key_request** | [**UpdateApiKeyRequest**](UpdateApiKeyRequest.md) |  |  |
+
+### Return type
+
+[**GetApiKey200Response**](GetApiKey200Response.md)
+
+### Authorization
+
+[BearerAuth](../README.md#BearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+

data/docs/ApiKey.md

@@ -0,0 +1,40 @@
+# QSafe::ApiKey
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  | [optional] |
+| **name** | **String** |  | [optional] |
+| **key_prefix** | **String** | Masked prefix of the API key (for identification only) | [optional] |
+| **permissions** | **Array<String>** |  | [optional] |
+| **rate_limit_per_hour** | **Integer** |  | [optional] |
+| **is_active** | **Boolean** |  | [optional] |
+| **usage_count** | **Integer** |  | [optional] |
+| **created_at** | **Time** |  | [optional] |
+| **updated_at** | **Time** |  | [optional] |
+| **expires_at** | **Time** |  | [optional] |
+| **allowed_ips** | **Array<String>** |  | [optional] |
+| **allowed_origins** | **Array<String>** |  | [optional] |
+
+## Example
+
+```ruby
+require 'qsafe-sdk'
+
+instance = QSafe::ApiKey.new(
+  id: 01cfd7fc-aa84-49aa-9a97-2dc68f736fac,
+  name: Production API Key,
+  key_prefix: pqc_8bf97ab3...,
+  permissions: ["read","crypto_encrypt","crypto_decrypt"],
+  rate_limit_per_hour: 1000,
+  is_active: true,
+  usage_count: 0,
+  created_at: null,
+  updated_at: null,
+  expires_at: null,
+  allowed_ips: ["192.168.1.0/24"],
+  allowed_origins: ["https://app.example.com"]
+)
+```
+

data/docs/AuthResponse.md

@@ -0,0 +1,20 @@
+# QSafe::AuthResponse
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **success** | **Boolean** |  | [optional] |
+| **data** | [**AuthResponseData**](AuthResponseData.md) |  | [optional] |
+
+## Example
+
+```ruby
+require 'qsafe-sdk'
+
+instance = QSafe::AuthResponse.new(
+  success: true,
+  data: null
+)
+```
+

data/docs/AuthResponseData.md

@@ -0,0 +1,26 @@
+# QSafe::AuthResponseData
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **access_token** | **String** | JWT access token — use as Bearer token in subsequent requests | [optional] |
+| **refresh_token** | **String** |  | [optional] |
+| **token_type** | **String** |  | [optional] |
+| **expires_in** | **String** | Token expiry duration (e.g. \"1h\") | [optional] |
+| **user** | [**User**](User.md) |  | [optional] |
+
+## Example
+
+```ruby
+require 'qsafe-sdk'
+
+instance = QSafe::AuthResponseData.new(
+  access_token: null,
+  refresh_token: null,
+  token_type: Bearer,
+  expires_in: 1h,
+  user: null
+)
+```
+