Kimlik Doğrulama

using System;
using System.Security.Cryptography;
using System.Text;

public sealed class PfSignatureService
{
    private readonly byte[] _secretKeyBytes;
    private readonly string _publicKey;
    private readonly string _secretKey;

    public PfSignatureService(string publicKey, string secretKey)
    {
        _publicKey = publicKey;
        _secretKey = secretKey;
        _secretKeyBytes = Convert.FromBase64String(secretKey);
    }

    public SignatureResult CreateSignature(string? conversationId = null)
    {
        string nonce = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds().ToString();
        conversationId ??= Guid.NewGuid().ToString("N")[..8];

        // 1. SecurityData
        string securityData = ComputeHmac(_publicKey + nonce);

        // 2. Signature
        string signature = ComputeHmac(_secretKey + conversationId + nonce + securityData);

        return new SignatureResult(nonce, signature, conversationId);
    }

    private string ComputeHmac(string data)
    {
        using var hmac = new HMACSHA256(_secretKeyBytes);
        return Convert.ToBase64String(
            hmac.ComputeHash(Encoding.UTF8.GetBytes(data))
        );
    }
}

public record SignatureResult(string Nonce, string Signature, string ConversationId);

// Kullanım:
// var service = new PfSignatureService("YOUR_PUBLIC_KEY", "YOUR_SECRET_KEY");
// var result = service.CreateSignature();
// Console.WriteLine(result.Signature);

import { createHmac } from 'node:crypto';

class PfSignatureService {
    #secretKeyBytes;
    #publicKey;
    #secretKey;

    constructor(publicKey, secretKey) {
        this.#publicKey = publicKey;
        this.#secretKey = secretKey;
        this.#secretKeyBytes = Buffer.from(secretKey, 'base64');
    }

    createSignature(conversationId) {
        const nonce = Date.now().toString();
        conversationId ??= crypto.randomUUID().slice(0, 8);

        // 1. SecurityData
        const securityData = this.#computeHmac(this.#publicKey + nonce);

        // 2. Signature
        const signature = this.#computeHmac(
            this.#secretKey + conversationId + nonce + securityData
        );

        return { nonce, signature, conversationId };
    }

    #computeHmac(data) {
        return createHmac('sha256', this.#secretKeyBytes)
            .update(data, 'utf8')
            .digest('base64');
    }
}

// Kullanım:
// const service = new PfSignatureService('YOUR_PUBLIC_KEY', 'YOUR_SECRET_KEY');
// const { nonce, signature, conversationId } = service.createSignature();

import hmac
import hashlib
import base64
import time
import uuid
from dataclasses import dataclass


@dataclass(frozen=True)
class SignatureResult:
    nonce: str
    signature: str
    conversation_id: str


class PfSignatureService:
    def __init__(self, public_key: str, secret_key: str):
        self._public_key = public_key
        self._secret_key = secret_key
        self._secret_key_bytes = base64.b64decode(secret_key)

    def create_signature(self, conversation_id: str | None = None) -> SignatureResult:
        nonce = str(int(time.time() * 1000))
        conversation_id = conversation_id or uuid.uuid4().hex[:8]

        # 1. SecurityData
        security_data = self._compute_hmac(self._public_key + nonce)

        # 2. Signature
        signature = self._compute_hmac(
            self._secret_key + conversation_id + nonce + security_data
        )

        return SignatureResult(nonce, signature, conversation_id)

    def _compute_hmac(self, data: str) -> str:
        return base64.b64encode(
            hmac.new(self._secret_key_bytes, data.encode('utf-8'), hashlib.sha256).digest()
        ).decode('utf-8')


# Kullanım:
# service = PfSignatureService('YOUR_PUBLIC_KEY', 'YOUR_SECRET_KEY')
# result = service.create_signature()
# print(result.signature)

<?php

class PfSignatureService
{
    private string $publicKey;
    private string $secretKey;
    private string $secretKeyBytes;

    public function __construct(string $publicKey, string $secretKey)
    {
        $this->publicKey = $publicKey;
        $this->secretKey = $secretKey;
        $this->secretKeyBytes = base64_decode($secretKey);
    }

    public function createSignature(?string $conversationId = null): array
    {
        $nonce = (string) round(microtime(true) * 1000);
        $conversationId = $conversationId ?? substr(bin2hex(random_bytes(4)), 0, 8);

        // 1. SecurityData
        $securityData = $this->computeHmac($this->publicKey . $nonce);

        // 2. Signature
        $signature = $this->computeHmac(
            $this->secretKey . $conversationId . $nonce . $securityData
        );

        return [
            'nonce'          => $nonce,
            'signature'      => $signature,
            'conversationId' => $conversationId,
        ];
    }

    private function computeHmac(string $data): string
    {
        return base64_encode(
            hash_hmac('sha256', $data, $this->secretKeyBytes, true)
        );
    }
}

// Kullanım:
// $service = new PfSignatureService('YOUR_PUBLIC_KEY', 'YOUR_SECRET_KEY');
// $result  = $service->createSignature();
// echo $result['signature'];