1

我被要求在数据库中隐藏用户的电子邮件。（平均堆栈）。

我是一个新手，我在管理一些包（如 maskdata、crypto.js）时遇到了一些困难……而且在某些时候，我受到了一个函数的启发。

在我的代码中，对于用户控制器，我有 2 个功能：一个用于注册（称为注册），一个用于登录（称为登录）

对于注册：

我在请求正文中接收电子邮件：req.body.email，我确实将它作为 ab 参数传递给一个名为 obfuscator 的函数，这个想法是用一系列数字和字母代替邮件，然后我将返回该参数的函数保存为数据库中用户邮件的值。

对于登录：

我在请求正文中接收电子邮件，并检查返回此 req.body.email 的内容，一旦传入函数混淆器，然后我会在数据库中搜索此结果作为用户的邮件值。

我看到它正在工作，那么我的代码是否有明显的问题，或者它可以接受吗？

我想这是一些非常糟糕的保护，但至少，用户的电子邮件没有清楚地出现在数据库中。

这是我的代码：

 function obfuscator(sentence) {
  var mail = [];  
  for (let i in sentence) {
    mail += sentence.charCodeAt(i).toString(process.env.BASE)
  }
  return mail
}


// inscription d'un utilisateur
exports.signup = (req, res, next) => {                   
  bcrypt.hash(req.body.password, 10)    // on hashe le mot de passe avec un salt de 10                                               
    .then(hash => {                                                         
      const user = new User({                                                         
        email: obfuscator(req.body.email),  // on sauve un mail encodé
        password: hash                  // et on assigne le hash obtenu comme valeur de la propriété password de l'objet user 
    });
   console.log(user)
    user.save()                       // et on sauve tout ça dans la base de données                                            
      .then(() => res.status(201).json({ message: 'new user created' }))            
      .catch(error => res.status(400).json({ error }));                             
  })
  .catch(error => res.status(500).json({ error }));                                 
};

// connexion de l'utilisateur
exports.login = (req, res, next) => {                                                 
  User.findOne({ email : obfuscator(req.body.email)}) // on recherche l'équivalent du mail encodé
    .then(user => {           // on recherche une objet de modèle User, ayant pour propriété "email" avec la même valeur que req.body.email                                                                                                    
      if (!user) {   // pas trouvé ? = message: user not found                                                                  
        return res.status(401).json({ message: 'user not found' }); 
      }
      bcrypt.compare(req.body.password, user.password)       // si on trouve, on prend le password et avec bcrypt on compare le passord and le requête avec le password du user trouvé dans la base de données                       
        .then(valid => {    
          if (!valid) {     // si le password n'est pas validé = message: incorrect password                                         
            return res.status(404).json({ message: "incorrect password" });           
          } // et si c'est valide....
          res.status(200).json({                                                      
            userId: user._id,        // dans la réponse on renvoir le user._id (ce _id est donc l'id généré dans mongoDB)
            token: jwt.sign(         // et on renvoie un token d'authentification
            { userId: user._id },                                                     
              process.env.TOKEN,                                                      
              { expiresIn: '24h' }   // avec une date d'expiration      
            )
          });
        })
        .catch(error => res.status(500).json({ error }));                             
    })
    .catch(error => res.status(500).json({ error }));                                 
};
4

1 回答 1

0

我确实回答了我自己的问题：

该功能正在运行。如果需要隐藏（混淆），例如，数据库中的电子邮件，它可以工作，它可以完成工作。

无论如何，最好使用经过验证的有效软件包来完成这项工作，而不是问题中提到的那个。

于 2020-12-14T07:20:23.030 回答