Conformidade PCI

Domine a conformidade com o PCI DSS (Payment Card Industry Data Security Standard) para processamento seguro de pagamentos e manuseio de dados do titular do cartão.

Quando Usar Esta Habilidade

• Construindo sistemas de processamento de pagamentos
• Lidando com informações de cartão de crédito
• Implementando fluxos de pagamento seguros
• Realizando auditorias de conformidade PCI
• Reduzindo o escopo de conformidade PCI
• Implementando tokenização e criptografia
• Preparando-se para avaliações PCI DSS

Requisitos PCI DSS (12 Requisitos Principais)

Construir e Manter Rede Segura

1. Instalar e manter a configuração do firewall
2. Não usar padrões fornecidos pelo fornecedor para senhas

Proteger Dados do Titular do Cartão

3. Proteger dados armazenados do titular do cartão
4. Criptografar a transmissão de dados do titular do cartão em redes públicas

Manter Gerenciamento de Vulnerabilidades

5. Proteger sistemas contra malware
6. Desenvolver e manter sistemas e aplicativos seguros

Implementar Controle de Acesso Forte

7. Restringir o acesso aos dados do titular do cartão por necessidade de conhecimento de negócios
8. Identificar e autenticar o acesso aos componentes do sistema
9. Restringir o acesso físico aos dados do titular do cartão

Monitorar e Testar Redes

10. Rastrear e monitorar todo o acesso a recursos de rede e dados do titular do cartão
11. Testar regularmente sistemas e processos de segurança

Manter Política de Segurança da Informação

12. Manter uma política que aborde a segurança da informação

Níveis de Conformidade

Nível 1: > 6 milhões de transações/ano (ROC anual exigido) Nível 2: 1-6 milhões de transações/ano (SAQ anual) Nível 3: 20.000-1 milhão de transações de e-commerce/ano Nível 4: < 20.000 transações de e-commerce ou < 1 milhão de transações totais

Minimização de Dados (Nunca Armazenar)

# NEVER STORE THESE
PROHIBITED_DATA = {
    'full_track_data': 'Magnetic stripe data',
    'cvv': 'Card verification code/value',
    'pin': 'PIN or PIN block'
}

# CAN STORE (if encrypted)
ALLOWED_DATA = {
    'pan': 'Primary Account Number (card number)',
    'cardholder_name': 'Name on card',
    'expiration_date': 'Card expiration',
    'service_code': 'Service code'
}

class PaymentData:
    """Safe payment data handling."""

    def __init__(self):
        self.prohibited_fields = ['cvv', 'cvv2', 'cvc', 'pin']

    def sanitize_log(self, data):
        """Remove sensitive data from logs."""
        sanitized = data.copy()

        # Mask PAN
        if 'card_number' in sanitized:
            card = sanitized['card_number']
            sanitized['card_number'] = f"{card[:6]}{'*' * (len(card) - 10)}{card[-4:]}"

        # Remove prohibited data
        for field in self.prohibited_fields:
            sanitized.pop(field, None)

        return sanitized

    def validate_no_prohibited_storage(self, data):
        """Ensure no prohibited data is being stored."""
        for field in self.prohibited_fields:
            if field in data:
                raise SecurityError(f"Attempting to store prohibited field: {field}")

Tokenização

Usando Tokens de Processador de Pagamento

import stripe

class TokenizedPayment:
    """Lida com pagamentos usando tokens (sem dados de cartão no servidor)."""

    @staticmethod
    def create_payment_method_token(card_details):
        """Cria token a partir dos detalhes do cartão (apenas no lado do cliente)."""
        # ISSO SÓ DEVE SER FEITO NO LADO DO CLIENTE COM STRIPE.JS
        # NUNCA envie detalhes do cartão para o seu servidor

        """
        // JavaScript no frontend
        const stripe = Stripe('pk_...');

        const {token, error} = await stripe.createToken({
            card: {
                number: '4242424242424242',
                exp_month: 12,
                exp_year: 2024,
                cvc: '123'
            }
        });

        // Envie token.id para o servidor (NÃO os detalhes do cartão)
        """
        pass

    @staticmethod
    def charge_with_token(token_id, amount):
        """Cobra usando token (lado do servidor)."""
        # Seu servidor vê apenas o token, nunca o número do cartão
        stripe.api_key = "sk_..."

        charge = stripe.Charge.create(
            amount=amount,
            currency="usd",
            source=token_id,  # Token em vez de detalhes do cartão
            description="Pagamento"
        )

        return charge

    @staticmethod
    def store_payment_method(customer_id, payment_method_token):
        """Armazena o método de pagamento como token para uso futuro."""
        stripe.Customer.modify(
            customer_id,
            source=payment_method_token
        )

        # Armazene apenas customer_id e payment_method_id em seu banco de dados

…