API Security

import { AuthenticationClient } from 'auth0';

const auth0Client = new AuthenticationClient({
  domain: 'dex.asia.auth.chainstream.io',
  clientId: process.env.CHAINSTREAM_CLIENT_ID,
  clientSecret: process.env.CHAINSTREAM_CLIENT_SECRET
});

const { data } = await auth0Client.oauth.clientCredentialsGrant({
  audience: 'https://api.dex.chainstream.io'
});

const accessToken = data.access_token;

from auth0.authentication import GetToken

get_token = GetToken(
    'dex.asia.auth.chainstream.io',
    os.environ['CHAINSTREAM_CLIENT_ID'],
    client_secret=os.environ['CHAINSTREAM_CLIENT_SECRET']
)

token = get_token.client_credentials(
    audience='https://api.dex.chainstream.io'
)

access_token = token['access_token']

// ❌ Dangerous: Hardcoded credentials
const clientId = "your_client_id";
const clientSecret = "your_secret";

// ❌ Dangerous: Committed to version control
// config.json: { "client_id": "...", "client_secret": "..." }

// ✅ Secure: Use environment variables
const clientId = process.env.CHAINSTREAM_CLIENT_ID;
const clientSecret = process.env.CHAINSTREAM_CLIENT_SECRET;

// ✅ Secure: Use secret management service
const credentials = await secretsManager.getSecret('chainstream-credentials');

import os

# ❌ Dangerous: Hardcoded
client_id = "your_client_id"
client_secret = "your_secret"

# ✅ Secure: Use environment variables
client_id = os.environ.get('CHAINSTREAM_CLIENT_ID')
client_secret = os.environ.get('CHAINSTREAM_CLIENT_SECRET')

# ✅ Secure: Use secret management service (AWS Secrets Manager example)
import boto3
client = boto3.client('secretsmanager')
credentials = client.get_secret_value(SecretId='chainstream-credentials')['SecretString']

// ❌ Dangerous: Hardcoded
clientID := "your_client_id"
clientSecret := "your_secret"

// ✅ Secure: Use environment variables
clientID := os.Getenv("CHAINSTREAM_CLIENT_ID")
clientSecret := os.Getenv("CHAINSTREAM_CLIENT_SECRET")

// ❌ Dangerous: Skip certificate validation
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';

// ✅ Secure: Normal certificate validation (default behavior)
const response = await fetch('https://api.chainstream.io/v1/...');

import requests

# ❌ Dangerous: Skip certificate validation
requests.get(url, verify=False)

# ✅ Secure: Normal certificate validation (default behavior)
requests.get(url)

# ❌ Dangerous: Skip certificate validation
curl -k https://api.chainstream.io/v1/...

# ✅ Secure: Normal certificate validation (default behavior)
curl https://api.chainstream.io/v1/...

const crypto = require('crypto');

function verifyWebhookSignature(payload, signature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(JSON.stringify(payload))
    .digest('hex');
  
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

// Express middleware example
app.post('/webhook', (req, res) => {
  const signature = req.headers['x-webhook-signature'];
  const isValid = verifyWebhookSignature(
    req.body,
    signature,
    process.env.WEBHOOK_SECRET
  );
  
  if (!isValid) {
    return res.status(401).send('Invalid signature');
  }
  
  // Process webhook message
  console.log('Received webhook:', req.body);
  res.status(200).send('OK');
});

import hmac
import hashlib
import json

def verify_webhook_signature(payload, signature, secret):
    expected_signature = hmac.new(
        secret.encode(),
        json.dumps(payload).encode(),
        hashlib.sha256
    ).hexdigest()
    
    return hmac.compare_digest(signature, expected_signature)

# Flask example
@app.route('/webhook', methods=['POST'])
def webhook():
    signature = request.headers.get('X-Webhook-Signature')
    is_valid = verify_webhook_signature(
        request.json,
        signature,
        os.environ['WEBHOOK_SECRET']
    )
    
    if not is_valid:
        return 'Invalid signature', 401
    
    # Process webhook message
    print('Received webhook:', request.json)
    return 'OK', 200