Laravel实现仅指定接收者可查看PDF的权限控制问题

Got it, let's fix that unprotected PDF link issue so only the intended receiver can access the file. Here are a few practical, production-ready approaches you can implement:

1. 基于用户身份的访问控制（最推荐） #

This is the standard solution for user-to-user file sharing systems, since it leverages your existing user authentication setup.

Step-by-Step Implementation: #

• First, ensure your system has proper user session validation (e.g., using sessions, JWT, or OAuth) — users must be logged in to access any protected resources.
• Create a database table to track file sharing relationships (let's call it file_shares) with these fields:
  • file_path: The relative/absolute path to the PDF on your server
  • sender_id: ID of the user who sent the file
  • receiver_id: ID of the user who should receive the file
  • created_at: Timestamp for auditing
• Add a middleware/filter to your file access route that checks if the current logged-in user matches the file's receiver (or sender, if you want senders to also view the file).
• Critical: Don't store PDFs in your web server's public static directory (e.g., Nginx's root folder) — this would bypass your permission checks entirely. Always serve files through your backend application.

Example Code (Node.js/Express):

const path = require('path');
const db = require('./your-db-connection'); // Your DB client

// Middleware to validate file access permissions
async function checkFileAccess(req, res, next) {
  const fileName = req.params.fileName;
  const currentUserId = req.user.id; // Pull user ID from session/JWT

  // Query DB to get the file's authorized receiver
  const [fileShare] = await db.query(
    'SELECT receiver_id FROM file_shares WHERE file_path = ?',
    [fileName]
  );

  // Reject access if no record exists or user isn't the receiver
  if (!fileShare || fileShare.receiver_id !== currentUserId) {
    return res.status(403).send('You do not have permission to access this file');
  }
  next();
}

// Protected route to serve PDFs
app.get('/files/:fileName', checkFileAccess, (req, res) => {
  const filePath = path.join(__dirname, 'server-pdf-storage', req.params.fileName);
  res.sendFile(filePath);
});

2. Signed Temporary Links (For Flexible Access) #

If you need to support scenarios where receivers might not be logged in temporarily, or want time-limited access, use signed links. This approach embeds encrypted permission details directly in the URL.

How It Works: #

• Generate a unique signed URL for each file share, including:
  • Receiver ID
  • File name/path
  • Expiration timestamp (e.g., 24 hours from creation)
• Use an HMAC hash (with a secret key stored in environment variables) to sign the URL parameters.
• When a user requests the link, your backend re-calculates the signature and verifies it matches the one in the URL, plus checks the receiver ID and expiration time.

Example Code (Generate Signed Link):

const crypto = require('crypto');
const SECRET_KEY = process.env.FILE_SIGNING_SECRET; // Store in env vars, never hardcode

function generateSignedShareLink(fileName, receiverId, expiresIn = 86400) {
  const exp = Math.floor(Date.now() / 1000) + expiresIn; // Expire in 24h
  const params = `receiver=${receiverId}&file=${fileName}&exp=${exp}`;
  const signature = crypto.createHmac('sha256', SECRET_KEY).update(params).digest('hex');
  return `/files/${fileName}?${params}&sig=${signature}`;
}

3. Direct File Content Forwarding #

Another secure option is to never expose the actual file path to clients. Instead, your backend reads the PDF content directly and sends it to authorized users as a response.

Example Code (Python/Flask):

from flask import Flask, send_file, abort, g
import os

app = Flask(__name__)

# Helper to get current logged-in user (adjust to your auth setup)
def get_current_user():
    return g.user

# Helper to fetch file info from DB
def get_file_share(file_id):
    # Replace with your DB query logic
    return db.execute("SELECT receiver_id, file_path FROM file_shares WHERE id = ?", (file_id,)).fetchone()

@app.route('/secure-pdf/<file_id>')
def serve_secure_pdf(file_id):
    current_user = get_current_user()
    file_share = get_file_share(file_id)

    if not file_share or file_share['receiver_id'] != current_user['id']:
        abort(403, description="You are not authorized to access this file")

    # Send file content directly without exposing path
    return send_file(
        file_share['file_path'],
        mimetype='application/pdf',
        as_attachment=False # Set to True if you want to force download
    )

Key Notes to Avoid Mistakes: #

• Never hardcode secrets: Store signing keys, DB credentials, etc., in environment variables.
• Index your DB table: Add an index on file_path and receiver_id to speed up permission checks.
• Audit access: Log all file access attempts for security auditing purposes.

内容的提问来源于stack exchange，提问作者Ahmed essam