Handling the Redirect URLs

{
    "txnid": "12345",
    "amount": "100.00",
    "productinfo": "Test Product",
    "firstname": "John",
    "email": "[email protected]",
    "phone": "9999999999",
    "surl": "http://example.com/success",
    "furl": "http://example.com/failure"
}

import hashlib
import requests
import os
import logging
from urllib.parse import urljoin

# Set up logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def generate_payu_hash(params, salt):
    """
    Generate secure hash for PayU transaction
    Using the correct format: key|txnid|amount|productinfo|firstname|email|udf1|udf2|udf3|udf4|udf5||||||SALT
    """
    # Extract required parameters
    key = params['key']
    txnid = params['txnid']
    amount = params['amount']
    productinfo = params['productinfo']
    firstname = params['firstname']
    email = params['email']
    
    # Get optional udf values or use empty string
    udf1 = params.get('udf1', '')
    udf2 = params.get('udf2', '')
    udf3 = params.get('udf3', '')
    udf4 = params.get('udf4', '')
    udf5 = params.get('udf5', '')
    
    # Create hash string with the exact format (11 pipes after email)
    hash_string = f"{key}|{txnid}|{amount}|{productinfo}|{firstname}|{email}|{udf1}|{udf2}|{udf3}|{udf4}|{udf5}||||||{salt}"
    
    # Generate SHA-512 hash
    return hashlib.sha512(hash_string.encode('utf-8')).hexdigest().lower()

def main():
    try:
        # Get credentials from environment variables (more secure)
        # Set these using: export PAYU_KEY=your_key && export PAYU_SALT=your_salt
        key = os.environ.get('PAYU_KEY')
        salt = os.environ.get('PAYU_SALT')
        
        if not key or not salt:
            raise ValueError("PayU credentials not found in environment variables. Set PAYU_KEY and PAYU_SALT.")
            
        # Set environment (test or production)
        is_test_env = os.environ.get('PAYU_TEST_MODE', 'true').lower() == 'true'
        base_url = "https://test.payu.in" if is_test_env else "https://secure.payu.in"
        payment_url = urljoin(base_url, "_payment")
            
        # Transaction details
        txnid = "txn" + str(int(time.time()))  # Unique transaction ID
        amount = "100.00"
        productinfo = "Product Description"
        firstname = "Customer Name"
        email = "[email protected]"
        phone = "9876543210"
        
        # Redirect URLs - must be valid and accessible
        surl = "https://yourdomain.com/payment/success"
        furl = "https://yourdomain.com/payment/failure"
        
        # Prepare parameters dictionary
        params = {
            "key": key,
            "txnid": txnid,
            "amount": amount,
            "productinfo": productinfo,
            "firstname": firstname,
            "email": email,
            "phone": phone,
            "surl": surl,
            "furl": furl,
            # Optional UDFs for your reference
            "udf1": "reference-123"  # You can use this for order ID or other reference
        }
        
        # Generate hash and add to parameters
        params["hash"] = generate_payu_hash(params, salt)
        
        logger.info(f"Initiating PayU transaction: {txnid}")
        
        # Send POST request to PayU API
        response = requests.post(payment_url, data=params, timeout=30)
        
        # Check response status
        if response.status_code == 200:
            logger.info(f"Successfully initiated payment for transaction: {txnid}")
            # Note: For actual integration, PayU will redirect the user to payment page
            # This direct API access is typically for testing only
            return response.text
        else:
            logger.error(f"Failed to initiate payment. Status code: {response.status_code}")
            logger.error(f"Response: {response.text}")
            return f"Error: {response.status_code} - {response.text}"
            
    except requests.exceptions.RequestException as e:
        logger.error(f"Request failed: {str(e)}")
        return f"Error: {str(e)}"
    except ValueError as e:
        logger.error(f"Value error: {str(e)}")
        return f"Error: {str(e)}"
    except Exception as e:
        logger.error(f"Unexpected error: {str(e)}")
        return f"Error: {str(e)}"

if __name__ == "__main__":
    import time
    result = main()
    print(result)

<?php
/**
 * PayU Payment Integration - Handling Redirect URLs
 * This sample demonstrates the correct way to integrate with PayU's payment API
 */

// Set proper error reporting for development
ini_set('display_errors', 1);
ini_set('display_startup_errors', 1);
error_reporting(E_ALL);

// Function to generate the PayU hash for secure transactions
function generatePayuHash($params, $salt) {
    // Extract required parameters
    $key = $params['key'];
    $txnid = $params['txnid'];
    $amount = $params['amount'];
    $productinfo = $params['productinfo'];
    $firstname = $params['firstname'];
    $email = $params['email'];
    
    // Get optional UDFs or use empty string
    $udf1 = isset($params['udf1']) ? $params['udf1'] : '';
    $udf2 = isset($params['udf2']) ? $params['udf2'] : '';
    $udf3 = isset($params['udf3']) ? $params['udf3'] : '';
    $udf4 = isset($params['udf4']) ? $params['udf4'] : '';
    $udf5 = isset($params['udf5']) ? $params['udf5'] : '';
    
    // Create hash string with exact format (11 pipes after email)
    $hashString = $key . '|' . $txnid . '|' . $amount . '|' . $productinfo . '|' . 
                  $firstname . '|' . $email . '|' . $udf1 . '|' . $udf2 . '|' . 
                  $udf3 . '|' . $udf4 . '|' . $udf5 . '||||||' . $salt;
    
    // Generate SHA-512 hash and convert to lowercase
    return strtolower(hash('sha512', $hashString));
}

// Main function to handle the payment process
function initiatePayuPayment() {
    try {
        // Get credentials from environment variables (more secure)
        // Set these in your server environment or .env file
        $key = getenv('PAYU_KEY');
        $salt = getenv('PAYU_SALT');
        
        if (!$key || !$salt) {
            throw new Exception("PayU credentials not found. Please set PAYU_KEY and PAYU_SALT environment variables.");
        }
        
        // Determine environment
        $isTestEnv = strtolower(getenv('PAYU_TEST_MODE') ?: 'true') === 'true';
        $paymentUrl = $isTestEnv ? 'https://test.payu.in/_payment' : 'https://secure.payu.in/_payment';
        
        // Transaction details
        $txnid = 'txn' . time();  // Unique transaction ID
        $amount = '100.00';
        $productinfo = 'Product Description';
        $firstname = 'Customer Name';
        $email = '[email protected]';
        $phone = '9876543210';
        
        // Redirect URLs - must be valid and accessible
        $surl = 'https://yourdomain.com/payment/success';
        $furl = 'https://yourdomain.com/payment/failure';
        
        // Validate redirect URLs
        if (!filter_var($surl, FILTER_VALIDATE_URL) || !filter_var($furl, FILTER_VALIDATE_URL)) {
            throw new Exception("Invalid redirect URLs. Please provide valid success and failure URLs.");
        }
        
        // Prepare parameters array
        $params = array(
            'key' => $key,
            'txnid' => $txnid,
            'amount' => $amount,
            'productinfo' => $productinfo,
            'firstname' => $firstname,
            'email' => $email,
            'phone' => $phone,
            'surl' => $surl,
            'furl' => $furl,
            'udf1' => 'reference-123'  // Optional - can be used for order reference
        );
        
        // Generate hash and add to parameters
        $params['hash'] = generatePayuHash($params, $salt);
        
        // Log the transaction initiation
        error_log("Initiating PayU transaction: {$txnid}");
        
        // Using cURL for better control and error handling
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $paymentUrl);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($params));
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 30);
        curl_setopt($ch, CURLOPT_TIMEOUT, 30);
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
        curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $error = curl_error($ch);
        curl_close($ch);
        
        // Check for errors
        if ($error) {
            error_log("cURL Error: {$error}");
            throw new Exception("Connection error: {$error}");
        }
        
        // Process response
        if ($httpCode == 200) {
            error_log("Successfully initiated payment for transaction: {$txnid}");
            
            // Note: For actual integration, PayU typically redirects the user
            // This direct API call approach is mainly for testing
            return [
                'success' => true,
                'message' => 'Payment initiated successfully',
                'txnid' => $txnid,
                'response' => $response
            ];
        } else {
            error_log("Failed to initiate payment. Status code: {$httpCode}");
            error_log("Response: {$response}");
            throw new Exception("Error initiating payment: HTTP {$httpCode}");
        }
        
    } catch (Exception $e) {
        error_log("PayU payment error: " . $e->getMessage());
        return [
            'success' => false,
            'message' => $e->getMessage()
        ];
    }
}

// Execute the payment function
$result = initiatePayuPayment();

// Output the result
if ($result['success']) {
    echo "Payment initiated successfully. Transaction ID: " . $result['txnid'];
} else {
    echo "Payment initiation failed: " . $result['message'];
}
?>

/**
 * PayU Payment Integration - Handling Redirect URLs (Node.js)
 * Server-side implementation for security best practices
 */

const crypto = require('crypto');
const axios = require('axios');
const express = require('express');
const bodyParser = require('body-parser');
require('dotenv').config(); // For loading environment variables

const app = express();
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());

/**
 * Generates the PayU hash for secure transactions
 * @param {Object} params - The payment parameters
 * @param {string} salt - The PayU salt
 * @returns {string} - The generated hash
 */
function generatePayuHash(params, salt) {
    // Extract required parameters
    const key = params.key;
    const txnid = params.txnid;
    const amount = params.amount;
    const productinfo = params.productinfo;
    const firstname = params.firstname;
    const email = params.email;
    
    // Get optional UDFs or use empty string
    const udf1 = params.udf1 || '';
    const udf2 = params.udf2 || '';
    const udf3 = params.udf3 || '';
    const udf4 = params.udf4 || '';
    const udf5 = params.udf5 || '';
    
    // Create hash string with exact format (11 pipes after email)
    const hashString = `${key}|${txnid}|${amount}|${productinfo}|${firstname}|${email}|${udf1}|${udf2}|${udf3}|${udf4}|${udf5}||||||${salt}`;
    
    // Generate SHA-512 hash and convert to lowercase
    return crypto.createHash('sha512').update(hashString).digest('hex').toLowerCase();
}

/**
 * Initiates a payment with PayU
 */
app.post('/api/initiate-payment', async (req, res) => {
    try {
        // Get credentials from environment variables
        const key = process.env.PAYU_KEY;
        const salt = process.env.PAYU_SALT;
        
        if (!key || !salt) {
            throw new Error('PayU credentials not configured. Set PAYU_KEY and PAYU_SALT environment variables.');
        }
        
        // Determine environment
        const isTestEnv = (process.env.PAYU_TEST_MODE || 'true').toLowerCase() === 'true';
        const paymentUrl = isTestEnv ? 'https://test.payu.in/_payment' : 'https://secure.payu.in/_payment';
        
        // Get customer and payment details from request
        // In a real app, validate all inputs thoroughly
        const { productinfo, amount, firstname, email, phone } = req.body;
        
        // Validate required fields
        if (!productinfo || !amount || !firstname || !email || !phone) {
            return res.status(400).json({ 
                success: false, 
                message: 'Missing required fields' 
            });
        }
        
        // Generate unique transaction ID
        const txnid = 'txn' + Date.now();
        
        // Redirect URLs - must be valid and accessible
        // In production, these should be configured in your app settings
        const baseUrl = process.env.APP_BASE_URL || 'https://yourdomain.com';
        const surl = `${baseUrl}/payment/success`;
        const furl = `${baseUrl}/payment/failure`;
        
        // Prepare parameters object
        const params = {
            key,
            txnid,
            amount,
            productinfo,
            firstname,
            email,
            phone,
            surl,
            furl,
            udf1: req.body.reference || '' // Optional - can be used for order reference
        };
        
        // Generate hash and add to parameters
        params.hash = generatePayuHash(params, salt);
        
        console.log(`Initiating PayU transaction: ${txnid}`);
        
        // Option 1: Return form data for client-side form submission
        // This is the recommended approach as it allows PayU to handle the redirect
        return res.status(200).json({
            success: true,
            message: 'Payment initiated',
            txnid,
            paymentUrl,
            formData: params
        });
        
        /* 
        // Option 2: Server-side API call (for testing only)
        // Note: In production, PayU expects a user's browser to submit the form
        const response = await axios.post(paymentUrl, params, {
            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
            timeout: 30000
        });
        
        console.log(`Payment initiated: ${txnid}`);
        return res.status(200).json({
            success: true,
            message: 'Payment initiated',
            txnid,
            data: response.data
        });
        */
        
    } catch (error) {
        console.error('PayU payment error:', error.message);
        return res.status(500).json({
            success: false,
            message: `Payment initiation failed: ${error.message}`
        });
    }
});

// Example route to render a payment form
app.get('/payment', (req, res) => {
    res.send(`
        <h1>Payment Form</h1>
        <form id="paymentForm">
            <div>
                <label for="productinfo">Product:</label>
                <input type="text" id="productinfo" name="productinfo" value="Product Description" required>
            </div>
            <div>
                <label for="amount">Amount:</label>
                <input type="text" id="amount" name="amount" value="100.00" required>
            </div>
            <div>
                <label for="firstname">Name:</label>
                <input type="text" id="firstname" name="firstname" required>
            </div>
            <div>
                <label for="email">Email:</label>
                <input type="email" id="email" name="email" required>
            </div>
            <div>
                <label for="phone">Phone:</label>
                <input type="text" id="phone" name="phone" required>
            </div>
            <div>
                <label for="reference">Reference (Optional):</label>
                <input type="text" id="reference" name="reference">
            </div>
            <button type="submit">Pay Now</button>
        </form>
        
        <script>
            document.getElementById('paymentForm').addEventListener('submit', async function(e) {
                e.preventDefault();
                
                // Get form data
                const formData = new FormData(this);
                const formObject = {};
                formData.forEach((value, key) => { formObject[key] = value });
                
                try {
                    // Send to your server endpoint
                    const response = await fetch('/api/initiate-payment', {
                        method: 'POST',
                        headers: { 'Content-Type': 'application/json' },
                        body: JSON.stringify(formObject)
                    });
                    
                    const result = await response.json();
                    
                    if (result.success) {
                        // Create and submit a form to PayU
                        const form = document.createElement('form');
                        form.method = 'POST';
                        form.action = result.paymentUrl;
                        
                        // Add all parameters as hidden fields
                        for (const key in result.formData) {
                            const input = document.createElement('input');
                            input.type = 'hidden';
                            input.name = key;
                            input.value = result.formData[key];
                            form.appendChild(input);
                        }
                        
                        // Add the form to the document and submit it
                        document.body.appendChild(form);
                        form.submit();
                    } else {
                        alert('Error: ' + result.message);
                    }
                } catch (error) {
                    console.error('Error:', error);
                    alert('An error occurred. Please try again.');
                }
            });
        </script>
    `);
});

// Start the server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
});

package com.example.payuintegration;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.time.Instant;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * PayU Payment Integration - Handling Redirect URLs
 * Java implementation with proper error handling and security practices
 */
public class PayURedirectUrlsHandler {
    private static final Logger LOGGER = Logger.getLogger(PayURedirectUrlsHandler.class.getName());
    
    // Environment variables for configuration (more secure)
    private static final String PAYU_KEY = System.getenv("PAYU_KEY");
    private static final String PAYU_SALT = System.getenv("PAYU_SALT");
    private static final boolean IS_TEST_ENV = "true".equalsIgnoreCase(System.getenv("PAYU_TEST_MODE"));
    
    /**
     * Generates the PayU hash for secure transactions
     * 
     * @param params Payment parameters
     * @param salt PayU salt for hash generation
     * @return Generated hash string
     * @throws NoSuchAlgorithmException If SHA-512 algorithm is not available
     */
    public static String generatePayuHash(Map<String, String> params, String salt) throws NoSuchAlgorithmException {
        // Extract required parameters
        String key = params.get("key");
        String txnid = params.get("txnid");
        String amount = params.get("amount");
        String productinfo = params.get("productinfo");
        String firstname = params.get("firstname");
        String email = params.get("email");
        
        // Get optional UDFs or use empty string
        String udf1 = params.getOrDefault("udf1", "");
        String udf2 = params.getOrDefault("udf2", "");
        String udf3 = params.getOrDefault("udf3", "");
        String udf4 = params.getOrDefault("udf4", "");
        String udf5 = params.getOrDefault("udf5", "");
        
        // Create hash string with exact format (11 pipes after email)
        String hashString = key + "|" + txnid + "|" + amount + "|" + productinfo + "|" + 
                           firstname + "|" + email + "|" + udf1 + "|" + udf2 + "|" + 
                           udf3 + "|" + udf4 + "|" + udf5 + "||||||" + salt;
        
        // Generate SHA-512 hash
        return hashCal("SHA-512", hashString).toLowerCase();
    }
    
    /**
     * Calculates hash using specified algorithm
     * 
     * @param algo Hash algorithm (e.g., SHA-512)
     * @param data Input string to hash
     * @return Hash value as hexadecimal string
     * @throws NoSuchAlgorithmException If the algorithm is not available
     */
    public static String hashCal(String algo, String data) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance(algo);
        byte[] digest = md.digest(data.getBytes(StandardCharsets.UTF_8));
        
        StringBuilder hash = new StringBuilder();
        for (byte b : digest) {
            hash.append(String.format("%02x", b & 0xff));
        }
        
        return hash.toString();
    }
    
    /**
     * URL-encodes a map of parameters
     * 
     * @param params Map of parameters to encode
     * @return URL-encoded string
     * @throws IOException If encoding fails
     */
    private static String encodeParams(Map<String, String> params) throws IOException {
        StringBuilder result = new StringBuilder();
        boolean first = true;
        
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (first) {
                first = false;
            } else {
                result.append("&");
            }
            
            result.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
            result.append("=");
            result.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
        }
        
        return result.toString();
    }
    
    /**
     * Initiates a payment with PayU
     * 
     * @return Result of the payment initiation
     */
    public static Map<String, Object> initiatePayment() {
        Map<String, Object> result = new HashMap<>();
        HttpURLConnection connection = null;
        
        try {
            // Validate credentials
            if (PAYU_KEY == null || PAYU_KEY.isEmpty() || PAYU_SALT == null || PAYU_SALT.isEmpty()) {
                throw new IllegalStateException("PayU credentials not found. Set PAYU_KEY and PAYU_SALT environment variables.");
            }
            
            // Determine API URL based on environment
            String paymentUrl = IS_TEST_ENV ? 
                "https://test.payu.in/_payment" : 
                "https://secure.payu.in/_payment";
            
            // Transaction details
            String txnid = "txn" + Instant.now().getEpochSecond();
            String amount = "100.00";
            String productinfo = "Product Description";
            String firstname = "Customer Name";
            String email = "[email protected]";
            String phone = "9876543210";
            
            // Redirect URLs - must be valid and accessible
            String surl = "https://yourdomain.com/payment/success";
            String furl = "https://yourdomain.com/payment/failure";
            
            // Prepare parameters map
            Map<String, String> params = new HashMap<>();
            params.put("key", PAYU_KEY);
            params.put("txnid", txnid);
            params.put("amount", amount);
            params.put("productinfo", productinfo);
            params.put("firstname", firstname);
            params.put("email", email);
            params.put("phone", phone);
            params.put("surl", surl);
            params.put("furl", furl);
            params.put("udf1", "reference-123");  // Optional - for your reference
            
            // Generate hash and add to parameters
            params.put("hash", generatePayuHash(params, PAYU_SALT));
            
            LOGGER.info("Initiating PayU transaction: " + txnid);
            
            // Encode parameters
            String postData = encodeParams(params);
            byte[] postDataBytes = postData.getBytes(StandardCharsets.UTF_8);
            
            // Set up connection
            URL url = new URL(paymentUrl);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            connection.setRequestProperty("Content-Length", String.valueOf(postDataBytes.length));
            connection.setRequestProperty("User-Agent", "Java PayU Integration");
            connection.setConnectTimeout(30000);
            connection.setReadTimeout(30000);
            connection.setDoOutput(true);
            
            // Send request
            try (OutputStream os = connection.getOutputStream()) {
                os.write(postDataBytes);
                os.flush();
            }
            
            // Get response code
            int responseCode = connection.getResponseCode();
            
            // Read response
            StringBuilder response = new StringBuilder();
            try (BufferedReader in = new BufferedReader(
                    new InputStreamReader(
                        responseCode >= 400 ? 
                        connection.getErrorStream() : 
                        connection.getInputStream(), 
                        StandardCharsets.UTF_8))) {
                
                String line;
                while ((line = in.readLine()) != null) {
                    response.append(line);
                }
            }
            
            // Process response
            if (responseCode == 200) {
                LOGGER.info("Successfully initiated payment for transaction: " + txnid);
                result.put("success", true);
                result.put("txnid", txnid);
                result.put("message", "Payment initiated successfully");
                result.put("response", response.toString());
            } else {
                LOGGER.log(Level.WARNING, "Failed to initiate payment. Status code: {0}", responseCode);
                LOGGER.warning("Response: " + response);
                result.put("success", false);
                result.put("message", "Error initiating payment: HTTP " + responseCode);
                result.put("response", response.toString());
            }
            
        } catch (Exception e) {
            LOGGER.log(Level.SEVERE, "Error in payment initiation", e);
            result.put("success", false);
            result.put("message", e.getMessage());
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
        
        return result;
    }
    
    /**
     * Main method for testing
     */
    public static void main(String[] args) {
        // For testing, you can set environment variables programmatically
        // In production, set these in your environment
        if (System.getenv("PAYU_KEY") == null) {
            // This is for testing only - in production use proper environment variables
            System.out.println("Setting test environment variables - FOR TESTING ONLY");
            
            Map<String, String> testEnv = new HashMap<>();
            testEnv.put("PAYU_KEY", "your_test_key");  // Replace with your test key
            testEnv.put("PAYU_SALT", "your_test_salt");  // Replace with your test salt
            testEnv.put("PAYU_TEST_MODE", "true");
            
            // Set environment variables (Java 9+ way)
            testEnv.forEach(System::setProperty);
        }
        
        Map<String, Object> result = initiatePayment();
        
        if ((boolean) result.get("success")) {
            System.out.println("Payment initiated successfully!");
            System.out.println("Transaction ID: " + result.get("txnid"));
        } else {
            System.out.println("Payment initiation failed: " + result.get("message"));
        }
    }
}