e169c492aa
- Introduced DexExample.swift demonstrating decentralized exchange operations including spot trading, perpetual futures, liquidity provision, order book management, and portfolio tracking. - Added IbcExample.swift showcasing inter-blockchain communication operations such as cross-chain transfers, channel management, packet handling, and relayer operations. - Created ZkExample.swift illustrating zero-knowledge proof operations including circuit compilation, proof generation and verification, and trusted setup ceremonies.
391 lines
13 KiB
C
391 lines
13 KiB
C
/**
|
|
* Synor Crypto SDK Examples for C
|
|
*
|
|
* Demonstrates quantum-resistant cryptographic operations:
|
|
* - Hybrid Ed25519 + Dilithium3 signatures
|
|
* - BIP-39 mnemonic generation and validation
|
|
* - Post-quantum algorithms (Falcon, SPHINCS+)
|
|
* - Key derivation functions
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <synor/crypto.h>
|
|
|
|
// Helper function to print hex
|
|
void print_hex(const uint8_t* data, size_t len, size_t max_len) {
|
|
size_t print_len = len < max_len ? len : max_len;
|
|
for (size_t i = 0; i < print_len; i++) {
|
|
printf("%02x", data[i]);
|
|
}
|
|
if (len > max_len) {
|
|
printf("...");
|
|
}
|
|
}
|
|
|
|
void mnemonic_example(synor_crypto_t* crypto) {
|
|
printf("=== Mnemonic Operations ===\n");
|
|
|
|
synor_error_t err;
|
|
synor_mnemonic_t* mnemonic = NULL;
|
|
|
|
// Generate a 24-word mnemonic (256-bit entropy)
|
|
err = synor_mnemonic_generate(crypto, 24, &mnemonic);
|
|
if (err != SYNOR_OK) {
|
|
fprintf(stderr, "Failed to generate mnemonic: %s\n", synor_error_string(err));
|
|
return;
|
|
}
|
|
|
|
printf("Generated mnemonic: %s\n", synor_mnemonic_get_phrase(mnemonic));
|
|
printf("Word count: %d\n", synor_mnemonic_get_word_count(mnemonic));
|
|
|
|
// Validate a mnemonic
|
|
synor_validation_result_t validation;
|
|
err = synor_mnemonic_validate(crypto, synor_mnemonic_get_phrase(mnemonic), &validation);
|
|
if (err == SYNOR_OK) {
|
|
printf("Valid: %s\n", validation.is_valid ? "true" : "false");
|
|
if (!validation.is_valid && validation.error) {
|
|
printf("Error: %s\n", validation.error);
|
|
}
|
|
}
|
|
|
|
// Convert mnemonic to seed
|
|
uint8_t seed[64];
|
|
size_t seed_len;
|
|
err = synor_mnemonic_to_seed(crypto, synor_mnemonic_get_phrase(mnemonic),
|
|
"optional-passphrase", seed, &seed_len);
|
|
if (err == SYNOR_OK) {
|
|
printf("Seed (hex): ");
|
|
print_hex(seed, seed_len, 16);
|
|
printf("\n");
|
|
}
|
|
|
|
// Word suggestions for autocomplete
|
|
char** suggestions;
|
|
size_t suggestion_count;
|
|
err = synor_mnemonic_suggest_words(crypto, "aban", 5, &suggestions, &suggestion_count);
|
|
if (err == SYNOR_OK) {
|
|
printf("Suggestions for 'aban': ");
|
|
for (size_t i = 0; i < suggestion_count; i++) {
|
|
printf("%s%s", suggestions[i], i < suggestion_count - 1 ? ", " : "");
|
|
}
|
|
printf("\n");
|
|
synor_string_array_free(suggestions, suggestion_count);
|
|
}
|
|
|
|
synor_mnemonic_free(mnemonic);
|
|
printf("\n");
|
|
}
|
|
|
|
void keypair_example(synor_crypto_t* crypto) {
|
|
printf("=== Keypair Operations ===\n");
|
|
|
|
synor_error_t err;
|
|
synor_hybrid_keypair_t* keypair = NULL;
|
|
|
|
// Generate a random keypair
|
|
err = synor_keypair_generate(crypto, &keypair);
|
|
if (err != SYNOR_OK) {
|
|
fprintf(stderr, "Failed to generate keypair: %s\n", synor_error_string(err));
|
|
return;
|
|
}
|
|
|
|
printf("Generated hybrid keypair:\n");
|
|
printf(" Ed25519 public key size: %zu bytes\n",
|
|
synor_keypair_get_ed25519_pubkey_size(keypair));
|
|
printf(" Dilithium public key size: %zu bytes\n",
|
|
synor_keypair_get_dilithium_pubkey_size(keypair));
|
|
printf(" Total public key size: %zu bytes\n",
|
|
synor_keypair_get_pubkey_size(keypair));
|
|
|
|
// Get addresses for different networks
|
|
char address[128];
|
|
printf("\nAddresses:\n");
|
|
|
|
synor_keypair_get_address(keypair, SYNOR_NETWORK_MAINNET, address, sizeof(address));
|
|
printf(" Mainnet: %s\n", address);
|
|
|
|
synor_keypair_get_address(keypair, SYNOR_NETWORK_TESTNET, address, sizeof(address));
|
|
printf(" Testnet: %s\n", address);
|
|
|
|
synor_keypair_get_address(keypair, SYNOR_NETWORK_DEVNET, address, sizeof(address));
|
|
printf(" Devnet: %s\n", address);
|
|
|
|
// Create keypair from mnemonic (deterministic)
|
|
synor_mnemonic_t* mnemonic = NULL;
|
|
synor_mnemonic_generate(crypto, 24, &mnemonic);
|
|
|
|
synor_hybrid_keypair_t* keypair2 = NULL;
|
|
err = synor_keypair_from_mnemonic(crypto, synor_mnemonic_get_phrase(mnemonic), "", &keypair2);
|
|
if (err == SYNOR_OK) {
|
|
synor_keypair_get_address(keypair2, SYNOR_NETWORK_MAINNET, address, sizeof(address));
|
|
printf("\nKeypair from mnemonic: %.20s...\n", address);
|
|
synor_keypair_free(keypair2);
|
|
}
|
|
|
|
// Derive child keypair using BIP-44 path
|
|
printf("Derivation path: m/44'/21337'/0'/0/0\n");
|
|
|
|
synor_mnemonic_free(mnemonic);
|
|
synor_keypair_free(keypair);
|
|
printf("\n");
|
|
}
|
|
|
|
void signing_example(synor_crypto_t* crypto) {
|
|
printf("=== Hybrid Signing ===\n");
|
|
|
|
synor_error_t err;
|
|
synor_hybrid_keypair_t* keypair = NULL;
|
|
|
|
// Generate keypair
|
|
err = synor_keypair_generate(crypto, &keypair);
|
|
if (err != SYNOR_OK) {
|
|
fprintf(stderr, "Failed to generate keypair\n");
|
|
return;
|
|
}
|
|
|
|
// Sign a message
|
|
const char* message = "Hello, quantum-resistant world!";
|
|
synor_hybrid_signature_t* signature = NULL;
|
|
|
|
err = synor_sign(crypto, keypair, (const uint8_t*)message, strlen(message), &signature);
|
|
if (err != SYNOR_OK) {
|
|
fprintf(stderr, "Failed to sign message\n");
|
|
synor_keypair_free(keypair);
|
|
return;
|
|
}
|
|
|
|
printf("Signature created:\n");
|
|
printf(" Ed25519 component: %zu bytes\n", synor_signature_get_ed25519_size(signature));
|
|
printf(" Dilithium component: %zu bytes\n", synor_signature_get_dilithium_size(signature));
|
|
printf(" Total signature size: %zu bytes\n", synor_signature_get_size(signature));
|
|
|
|
// Verify the signature
|
|
bool valid;
|
|
err = synor_verify(crypto, keypair, (const uint8_t*)message, strlen(message), signature, &valid);
|
|
printf("\nVerification result: %s\n", valid ? "true" : "false");
|
|
|
|
// Verify with tampered message fails
|
|
const char* tampered = "Hello, tampered message!";
|
|
err = synor_verify(crypto, keypair, (const uint8_t*)tampered, strlen(tampered), signature, &valid);
|
|
printf("Tampered message verification: %s\n", valid ? "true" : "false");
|
|
|
|
synor_signature_free(signature);
|
|
synor_keypair_free(keypair);
|
|
printf("\n");
|
|
}
|
|
|
|
void falcon_example(synor_crypto_t* crypto) {
|
|
printf("=== Falcon Post-Quantum Signatures ===\n");
|
|
|
|
synor_error_t err;
|
|
|
|
// Generate Falcon-512 keypair (128-bit security)
|
|
synor_falcon_keypair_t* falcon512 = NULL;
|
|
err = synor_falcon_generate(crypto, SYNOR_FALCON_512, &falcon512);
|
|
if (err == SYNOR_OK) {
|
|
printf("Falcon-512 keypair:\n");
|
|
printf(" Public key: %zu bytes\n", synor_falcon_get_pubkey_size(falcon512));
|
|
printf(" Security level: 128-bit\n");
|
|
}
|
|
|
|
// Generate Falcon-1024 keypair (256-bit security)
|
|
synor_falcon_keypair_t* falcon1024 = NULL;
|
|
err = synor_falcon_generate(crypto, SYNOR_FALCON_1024, &falcon1024);
|
|
if (err == SYNOR_OK) {
|
|
printf("\nFalcon-1024 keypair:\n");
|
|
printf(" Public key: %zu bytes\n", synor_falcon_get_pubkey_size(falcon1024));
|
|
printf(" Security level: 256-bit\n");
|
|
}
|
|
|
|
// Sign with Falcon-512
|
|
const char* message = "Post-quantum secure message";
|
|
synor_falcon_signature_t* signature = NULL;
|
|
|
|
err = synor_falcon_sign(crypto, falcon512, (const uint8_t*)message, strlen(message), &signature);
|
|
if (err == SYNOR_OK) {
|
|
printf("\nFalcon-512 signature: %zu bytes\n", synor_falcon_signature_size(signature));
|
|
|
|
// Verify
|
|
bool valid;
|
|
err = synor_falcon_verify(crypto, falcon512, (const uint8_t*)message, strlen(message),
|
|
signature, &valid);
|
|
printf("Verification: %s\n", valid ? "true" : "false");
|
|
synor_falcon_signature_free(signature);
|
|
}
|
|
|
|
synor_falcon_keypair_free(falcon512);
|
|
synor_falcon_keypair_free(falcon1024);
|
|
printf("\n");
|
|
}
|
|
|
|
void sphincs_example(synor_crypto_t* crypto) {
|
|
printf("=== SPHINCS+ Hash-Based Signatures ===\n");
|
|
|
|
synor_error_t err;
|
|
|
|
// SPHINCS+ variants with different security levels
|
|
struct {
|
|
synor_sphincs_variant_t variant;
|
|
int security;
|
|
int sig_size;
|
|
const char* name;
|
|
} variants[] = {
|
|
{SYNOR_SPHINCS_SHAKE128S, 128, 7856, "SHAKE128S"},
|
|
{SYNOR_SPHINCS_SHAKE192S, 192, 16224, "SHAKE192S"},
|
|
{SYNOR_SPHINCS_SHAKE256S, 256, 29792, "SHAKE256S"},
|
|
};
|
|
|
|
const char* message = "Hash-based quantum security";
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
synor_sphincs_keypair_t* keypair = NULL;
|
|
err = synor_sphincs_generate(crypto, variants[i].variant, &keypair);
|
|
if (err != SYNOR_OK) continue;
|
|
|
|
printf("SPHINCS+ %s:\n", variants[i].name);
|
|
printf(" Security level: %d-bit\n", variants[i].security);
|
|
printf(" Expected signature size: %d bytes\n", variants[i].sig_size);
|
|
|
|
// Sign a message
|
|
synor_sphincs_signature_t* signature = NULL;
|
|
err = synor_sphincs_sign(crypto, keypair, (const uint8_t*)message, strlen(message), &signature);
|
|
if (err == SYNOR_OK) {
|
|
printf(" Actual signature size: %zu bytes\n", synor_sphincs_signature_size(signature));
|
|
|
|
// Verify
|
|
bool valid;
|
|
synor_sphincs_verify(crypto, keypair, (const uint8_t*)message, strlen(message),
|
|
signature, &valid);
|
|
printf(" Verification: %s\n\n", valid ? "true" : "false");
|
|
synor_sphincs_signature_free(signature);
|
|
}
|
|
|
|
synor_sphincs_keypair_free(keypair);
|
|
}
|
|
}
|
|
|
|
void kdf_example(synor_crypto_t* crypto) {
|
|
printf("=== Key Derivation Functions ===\n");
|
|
|
|
synor_error_t err;
|
|
|
|
// HKDF (HMAC-based Key Derivation Function)
|
|
const char* seed = "master-secret-key-material-here";
|
|
const char* salt = "application-salt";
|
|
const char* info = "encryption-key";
|
|
|
|
uint8_t derived_key[32];
|
|
synor_derivation_config_t hkdf_config = {
|
|
.salt = (const uint8_t*)salt,
|
|
.salt_len = strlen(salt),
|
|
.info = (const uint8_t*)info,
|
|
.info_len = strlen(info),
|
|
.output_length = 32
|
|
};
|
|
|
|
err = synor_kdf_derive(crypto, (const uint8_t*)seed, strlen(seed), &hkdf_config,
|
|
derived_key, sizeof(derived_key));
|
|
if (err == SYNOR_OK) {
|
|
printf("HKDF derived key: ");
|
|
print_hex(derived_key, 32, 32);
|
|
printf("\n");
|
|
}
|
|
|
|
// PBKDF2 (Password-Based Key Derivation Function)
|
|
const char* password = "user-password";
|
|
const char* pbkdf2_salt = "random-salt-value";
|
|
|
|
uint8_t password_key[32];
|
|
synor_password_config_t pbkdf2_config = {
|
|
.salt = (const uint8_t*)pbkdf2_salt,
|
|
.salt_len = strlen(pbkdf2_salt),
|
|
.iterations = 100000,
|
|
.output_length = 32
|
|
};
|
|
|
|
err = synor_kdf_derive_password(crypto, (const uint8_t*)password, strlen(password),
|
|
&pbkdf2_config, password_key, sizeof(password_key));
|
|
if (err == SYNOR_OK) {
|
|
printf("PBKDF2 derived key: ");
|
|
print_hex(password_key, 32, 32);
|
|
printf("\n");
|
|
}
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
void hash_example(synor_crypto_t* crypto) {
|
|
printf("=== Hash Functions ===\n");
|
|
|
|
synor_error_t err;
|
|
const char* data = "Data to hash";
|
|
uint8_t hash[32];
|
|
|
|
// SHA3-256 (FIPS 202)
|
|
err = synor_hash_sha3_256(crypto, (const uint8_t*)data, strlen(data), hash);
|
|
if (err == SYNOR_OK) {
|
|
printf("SHA3-256: ");
|
|
print_hex(hash, 32, 32);
|
|
printf("\n");
|
|
}
|
|
|
|
// BLAKE3 (fast, parallel)
|
|
err = synor_hash_blake3(crypto, (const uint8_t*)data, strlen(data), hash);
|
|
if (err == SYNOR_OK) {
|
|
printf("BLAKE3: ");
|
|
print_hex(hash, 32, 32);
|
|
printf("\n");
|
|
}
|
|
|
|
// Keccak-256 (Ethereum compatible)
|
|
err = synor_hash_keccak256(crypto, (const uint8_t*)data, strlen(data), hash);
|
|
if (err == SYNOR_OK) {
|
|
printf("Keccak: ");
|
|
print_hex(hash, 32, 32);
|
|
printf("\n");
|
|
}
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
synor_error_t err;
|
|
|
|
// Initialize client
|
|
synor_crypto_config_t config = {
|
|
.api_key = getenv("SYNOR_API_KEY") ? getenv("SYNOR_API_KEY") : "your-api-key",
|
|
.endpoint = "https://crypto.synor.io/v1",
|
|
.timeout_ms = 30000,
|
|
.retries = 3,
|
|
.debug = false,
|
|
.default_network = SYNOR_NETWORK_MAINNET
|
|
};
|
|
|
|
synor_crypto_t* crypto = NULL;
|
|
err = synor_crypto_init(&config, &crypto);
|
|
if (err != SYNOR_OK) {
|
|
fprintf(stderr, "Failed to initialize crypto client: %s\n", synor_error_string(err));
|
|
return 1;
|
|
}
|
|
|
|
// Check service health
|
|
bool healthy;
|
|
err = synor_crypto_health_check(crypto, &healthy);
|
|
printf("Service healthy: %s\n\n", healthy ? "true" : "false");
|
|
|
|
// Run examples
|
|
mnemonic_example(crypto);
|
|
keypair_example(crypto);
|
|
signing_example(crypto);
|
|
falcon_example(crypto);
|
|
sphincs_example(crypto);
|
|
kdf_example(crypto);
|
|
hash_example(crypto);
|
|
|
|
// Cleanup
|
|
synor_crypto_free(crypto);
|
|
|
|
return 0;
|
|
}
|