# 创建节点时password字段加盐加密的方法
通过API创建节点时password字段需要加盐加密，具体方法如下：
![](https://support.huaweicloud.com/api-cce/public_sys-resources/note_3.0-zh-cn.png)
盐值需要根据密码的要求来设置，密码复杂度要求如下：
- 长度为8-26位。
- 密码至少必须包含大写字母、小写字母、数字和特殊字符（!@$%\^-_=+\[{}\]:,./?）中的三种。
- 密码不能包含用户名或用户名的逆序。
- Windows系统密码不能包含用户名或用户名的逆序，不能包含用户名中超过两个连续字符的部分。
 
#### Python
**以下是Python 3.7.7环境下对密码进行加盐的示例步骤：**
```
pip install passlib
python -c "import base64; from passlib.hash import sha512_crypt; salted_password = base64.b64encode(sha512_crypt.hash('*****', salt='salt', rounds=5000).encode()).decode(); print(salted_password)"
```
![](https://support.huaweicloud.com/api-cce/public_sys-resources/note_3.0-zh-cn.png)
macOS下python crypt包有兼容性问题，如碰到无法执行的情况，请在Linux下执行。
#### Java
**以下是Java环境下对密码进行加盐的示例步骤：**
1. 获取随机数作为生成盐值：
   ```
   private static String getCharAndNumr(int length) {
           String val = "";
           Random random = new SecureRandom();
           for (int i = 0; i < length; i++) {
               // 输出字母还是数字
               String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";
               // 字符串
               if ("char".equalsIgnoreCase(charOrNum)) {
                   // 取得大写字母还是小写字母
                   int choice = random.nextInt(2) % 2 == 0 ? 65 : 97;
                   val += (char) (choice + random.nextInt(26));
               } else if ("num".equalsIgnoreCase(charOrNum)) { // 数字
                   val += String.valueOf(random.nextInt(10));
               }
           }
           return val;
       }
   ```
   
2. 生成盐值：
   ```
   private static String generateSalt() {
           String salt;
           try {
               salt = "$6$" + getCharAndNumr(16);
           }catch (Exception e){
               salt = defaultSalt;
           }
           return salt;
       }
   ```
   
3. 根据盐值生成密文密码：
   ```
   public static String getSaltPassword(String password) {
           if(StringUtils.isBlank(password)) {
               throw new BizException("password is empty");
           }
           String salt = generateSalt();
           Crypt crypt = new Crypt();
           return crypt.crypt(password, salt);
       }
   ```
   
4. 使用base64 encode（即为password字段值）：
   ```
   (Base64.getEncoder().encodeToString(AddSaltPasswordUtil.getSaltPassword(cceNodeCreateVo.getPassword()).getBytes()))
   ```
   
5. 完整样例如下：
   ```
   import java.util.Base64;
   import java.util.Random;
   import java.security.SecureRandom;
   import org.apache.commons.codec.digest.Crypt;
   import org.apache.commons.lang.StringUtils;
   public class PassWord {
       
       static String defaultSalt = null;
       
       public static void main(String[] args) throws Exception {
           System.out.println(Base64.getEncoder().encodeToString(PassWord.getSaltPassword("自定义password").getBytes()));
       }   
       
       
       //根据盐值生成密文密码
       public static String getSaltPassword(String password) throws Exception {
           if(StringUtils.isBlank(password)) {
               throw new Exception("password is empty");
           }
           String salt = generateSalt();
           return Crypt.crypt(password, salt);
       }
       
       //生成盐值
       private static String generateSalt() {
           String salt;
           try {
               salt = "$6$" + getCharAndNumr(16);
           }catch (Exception e){
               salt = defaultSalt;
           }
           return salt;
       }
       
       //获取随机数作为生成盐值
       private static String getCharAndNumr(int length) {
           String val = "";
           Random random = new SecureRandom();
           for (int i = 0; i < length; i++) {
               // 输出字母还是数字
               String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";
               // 字符串
               if ("char".equalsIgnoreCase(charOrNum)) {
                   // 取得大写字母还是小写字母
                   int choice = random.nextInt(2) % 2 == 0 ? 65 : 97;
                   val += (char) (choice + random.nextInt(26));
               } else if ("num".equalsIgnoreCase(charOrNum)) { // 数字
                   val += String.valueOf(random.nextInt(10));
               }
           }
           return val;
       }
   }
   ```
   
 
#### Go
**以下是Go环境下对密码进行加盐的完整样例：**
```
package main  
  
import (  
    "crypto/rand"  
    "encoding/base64" 
    "fmt"
    "io"  
    "github.com/GehirnInc/crypt"  
    _ "github.com/GehirnInc/crypt/sha512_crypt"  
)  
  
var letters = []byte("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")  
  
// 生成指定长度的随机盐值（salt），并将其字符限制在 letters 数组中。  
func Salt(size int) ([]byte, error) {  
    salt := make([]byte, size)  
    _, err := io.ReadFull(rand.Reader, salt)  
    if err != nil {  
       return nil, fmt.Errorf("error generating salt: %s", err)  
    }  
  
    max := uint8(len(letters))  
    arc := uint8(0)  
    for i, x := range salt {  
       arc = x % max  
       salt[i] = letters[arc]  
    }  
    return salt, nil  
}  
  
// 使用 SHA-512 算法对给定的密码进行加密，并返回 Base64 编码的加密结果。  
func PasswordEncrypt(password string) (string, error) {  
    saltBytes, err := Salt(16)  
    if err != nil {  
       return "", err  
    }  
    salt := "$6$" + string(saltBytes) + "$"  
  
    sha512crypt := crypt.SHA512.New()  
    passwordEncrypted, err := sha512crypt.Generate([]byte(password), []byte(salt))  
    if err != nil {  
       return "", fmt.Errorf("error encrypting the password: %s", err)  
    }  
    return base64.StdEncoding.EncodeToString([]byte(passwordEncrypted)), nil  
}  
  
// 尝试对给定的密码进行加密，如果密码已经是 Base64 编码的，则直接返回。  
func TryPasswordEncrypt(password string) (string, error) {  
    if _, err := base64.StdEncoding.DecodeString(password); err != nil {  
       return PasswordEncrypt(password)  
    }  
    return password, nil  
}  
// 修改自定义密码，进行加密
func main() {  
    encrypt, err := TryPasswordEncrypt("自定义密码")  
    if err != nil {  
       return  
    }  
    fmt.Println(encrypt)  
}
```
您可以修改上述样例中的自定义密码，执行代码后将输出加盐后的密码。
![](https://support.huaweicloud.com/api-cce/zh-cn_image_0000002455839209.png)