文件权限与模式

在Node.js中，文件权限与模式是文件系统操作的核心概念之一。理解如何设置和检查文件权限，以及如何通过模式控制文件访问，对于构建安全可靠的应用程序至关重要。

文件权限基础

文件权限通常分为三类：

• 所有者权限（User）
• 组权限（Group）
• 其他用户权限（Others）

每种权限又包含三种操作：

• 读取（r）
• 写入（w）
• 执行（x）

在Unix-like系统中，权限通常用八进制数表示，例如755表示：

• 所有者：读、写、执行（7）
• 组：读、执行（5）
• 其他用户：读、执行（5）

Node.js中的权限表示

Node.js使用数字模式来表示文件权限。以下是一些常见模式：

const fs = require('fs');

// 常见权限模式
const modes = {
  READ_ONLY: 0o444,    // r--r--r--
  READ_WRITE: 0o644,   // rw-r--r--
  FULL_ACCESS: 0o777,  // rwxrwxrwx
  EXECUTABLE: 0o755    // rwxr-xr-x
};

检查文件权限

使用fs.access()方法可以检查文件权限：

fs.access('/path/to/file', fs.constants.R_OK | fs.constants.W_OK, (err) => {
  if (err) {
    console.error('文件不可读写');
  } else {
    console.log('文件可读写');
  }
});

同步版本：

try {
  fs.accessSync('/path/to/file', fs.constants.R_OK);
  console.log('文件可读');
} catch (err) {
  console.error('文件不可读');
}

修改文件权限

使用fs.chmod()可以修改文件权限：

// 设置文件为可读可写
fs.chmod('/path/to/file', 0o644, (err) => {
  if (err) throw err;
  console.log('权限修改成功');
});

同步版本：

try {
  fs.chmodSync('/path/to/file', 0o755);
  console.log('权限修改成功');
} catch (err) {
  console.error('修改权限失败', err);
}

文件创建时的权限

创建文件时可以指定初始权限：

fs.writeFile('newfile.txt', '内容', { mode: 0o600 }, (err) => {
  if (err) throw err;
  console.log('文件创建成功，权限为600');
});

符号链接权限

处理符号链接时需要注意：

// 创建符号链接
fs.symlink('target.txt', 'link.txt', (err) => {
  if (err) throw err;
  
  // 获取符号链接本身的权限
  fs.lstat('link.txt', (err, stats) => {
    if (err) throw err;
    console.log(`符号链接权限: ${stats.mode.toString(8)}`);
  });
});

目录权限

目录权限与文件权限有所不同：

// 创建具有特定权限的目录
fs.mkdir('newdir', { mode: 0o755 }, (err) => {
  if (err) throw err;
  console.log('目录创建成功');
});

权限掩码（umask）

umask影响新创建文件的默认权限：

const oldMask = process.umask(0o022); // 设置新的umask

fs.writeFile('umask-file.txt', '内容', (err) => {
  process.umask(oldMask); // 恢复原umask
  if (err) throw err;
  
  fs.stat('umask-file.txt', (err, stats) => {
    if (err) throw err;
    console.log(`实际权限: ${stats.mode.toString(8)}`);
  });
});

高级权限检查

对于更复杂的权限检查，可以使用fs.stat()：

fs.stat('somefile', (err, stats) => {
  if (err) throw err;
  
  // 检查所有者是否有写权限
  const hasOwnerWrite = !!(stats.mode & fs.constants.S_IWUSR);
  
  // 检查是否设置了setuid位
  const isSetuid = !!(stats.mode & fs.constants.S_ISUID);
  
  console.log(`所有者可写: ${hasOwnerWrite}, setuid位: ${isSetuid}`);
});

跨平台注意事项

Windows系统处理权限的方式与Unix不同：

// 在Windows上创建可执行文件
if (process.platform === 'win32') {
  fs.chmod('script.bat', 0o755, (err) => {
    // Windows会忽略执行位
  });
}

实际应用示例

实现一个安全的配置文件读写：

const CONFIG_FILE = 'config.json';
const CONFIG_PERMS = 0o600; // 仅所有者可读写

function readConfig() {
  try {
    // 首先检查权限是否安全
    const stats = fs.statSync(CONFIG_FILE);
    if ((stats.mode & 0o777) !== CONFIG_PERMS) {
      throw new Error('配置文件权限不安全');
    }
    
    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
  } catch (err) {
    console.error('读取配置失败:', err);
    return null;
  }
}

function writeConfig(data) {
  try {
    const exists = fs.existsSync(CONFIG_FILE);
    
    // 如果文件不存在，创建时设置权限
    if (!exists) {
      fs.writeFileSync(CONFIG_FILE, JSON.stringify(data), {
        mode: CONFIG_PERMS
      });
    } else {
      // 文件存在，先检查权限
      const stats = fs.statSync(CONFIG_FILE);
      if ((stats.mode & 0o777) !== CONFIG_PERMS) {
        throw new Error('配置文件权限不安全');
      }
      
      fs.writeFileSync(CONFIG_FILE, JSON.stringify(data));
    }
    
    return true;
  } catch (err) {
    console.error('写入配置失败:', err);
    return false;
  }
}

错误处理最佳实践

处理权限相关错误时应考虑多种情况：

function safeFileOperation(path) {
  try {
    // 先检查是否存在
    fs.accessSync(path, fs.constants.F_OK);
    
    // 检查是否可读
    fs.accessSync(path, fs.constants.R_OK);
    
    // 执行操作
    const data = fs.readFileSync(path, 'utf8');
    return processData(data);
  } catch (err) {
    switch (err.code) {
      case 'ENOENT':
        console.error('文件不存在');
        break;
      case 'EACCES':
        console.error('权限不足');
        break;
      case 'EPERM':
        console.error('操作不允许');
        break;
      default:
        console.error('未知错误:', err);
    }
    return null;
  }
}

文件权限与安全

正确处理文件权限对应用安全至关重要：

// 不安全的示例
function unsafeWrite(data) {
  // 没有检查现有权限
  fs.writeFile('/etc/config.cfg', data, (err) => {
    // ...
  });
}

// 更安全的版本
function safeWrite(data) {
  fs.stat('/etc/config.cfg', (err, stats) => {
    if (err) {
      if (err.code === 'ENOENT') {
        // 新文件，设置严格权限
        fs.writeFile('/etc/config.cfg', data, { mode: 0o600 }, onComplete);
      } else {
        onComplete(err);
      }
    } else {
      // 检查现有权限
      if ((stats.mode & 0o777) !== 0o600) {
        return onComplete(new Error('文件权限不安全'));
      }
      fs.writeFile('/etc/config.cfg', data, onComplete);
    }
  });
  
  function onComplete(err) {
    if (err) console.error('写入失败:', err);
  }
}

递归修改目录权限

处理目录结构时需要递归修改权限：

const path = require('path');

function setPermissions(dir, fileMode, dirMode, callback) {
  fs.readdir(dir, (err, items) => {
    if (err) return callback(err);
    
    let pending = items.length;
    if (!pending) return callback(null);
    
    items.forEach((item) => {
      const fullPath = path.join(dir, item);
      
      fs.stat(fullPath, (err, stats) => {
        if (err) return callback(err);
        
        if (stats.isDirectory()) {
          // 递归处理子目录
          setPermissions(fullPath, fileMode, dirMode, (err) => {
            if (err) return callback(err);
            
            // 设置目录权限
            fs.chmod(fullPath, dirMode, (err) => {
              if (err) return callback(err);
              if (--pending === 0) callback(null);
            });
          });
        } else {
          // 设置文件权限
          fs.chmod(fullPath, fileMode, (err) => {
            if (err) return callback(err);
            if (--pending === 0) callback(null);
          });
        }
      });
    });
  });
}

// 使用示例
setPermissions('mydir', 0o644, 0o755, (err) => {
  if (err) console.error(err);
  else console.log('所有权限设置完成');
});

文件权限与进程用户

进程的用户身份影响文件权限检查：

const process = require('process');

console.log('进程用户信息:', {
  uid: process.getuid(),  // 用户ID
  gid: process.getgid(),  // 组ID
  euid: process.geteuid() // 有效用户ID
});

// 以不同用户身份运行程序时
function canWriteToSystemFile() {
  try {
    fs.accessSync('/etc/hosts', fs.constants.W_OK);
    return true;
  } catch (err) {
    return false;
  }
}

console.log('可以写入系统文件:', canWriteToSystemFile());

临时文件的安全创建

创建临时文件时需要注意权限：

const os = require('os');
const crypto = require('crypto');

function createTempFile(data) {
  const tempDir = os.tmpdir();
  const tempName = crypto.randomBytes(8).toString('hex') + '.tmp';
  const tempPath = path.join(tempDir, tempName);
  
  try {
    // 确保使用安全权限创建文件
    fs.writeFileSync(tempPath, data, { mode: 0o600 });
    return tempPath;
  } catch (err) {
    console.error('创建临时文件失败:', err);
    return null;
  }
}

文件权限与容器环境

在容器环境中权限处理可能有特殊要求：

// 检查是否在容器中运行
const isContainer = fs.existsSync('/.dockerenv') || 
                    fs.existsSync('/run/.containerenv');

function configureForContainer() {
  if (isContainer) {
    // 容器中通常需要放宽某些权限限制
    process.umask(0o002);
    
    // 确保关键目录可访问
    const requiredDirs = ['/data', '/config'];
    requiredDirs.forEach(dir => {
      try {
        fs.accessSync(dir, fs.constants.R_OK | fs.constants.W_OK);
      } catch (err) {
        console.warn(`目录 ${dir} 不可访问，尝试修改权限`);
        try {
          fs.chmodSync(dir, 0o777);
        } catch (chmodErr) {
          console.error(`无法修改 ${dir} 权限:`, chmodErr);
        }
      }
    });
  }
}