在轻量化平台上，目前已有登录界面login.html、服务配置界面conf.html、服务状态监控界面transList.html，现在要求**用户在登录之后可以*修改密码*。**
 
需求
 
1、口令长度至少6个字符；
2、口令必须包含如下至少两种字符的组合:
  －至少一个小写字母；
  －至少一个大写字母；
  －至少一个数字；
  －至少一个特殊字符：`~!@#$%^&*()-_=+\|[{}];:'",<.>/?  和空格
3.系统禁止明文显示口令及口令存储安全
	- 口令需加密保护，不能够明文写入日志文件、配置文件以及cookie中；
	- 口令文件必须设置访问控制，普通用户不能读取或拷贝加密的内容；
	- 操作界面中的口令不能明文显示；
	- 口令输入框内容禁止拷贝；
	- 口令不能在网络中明文传输
4.	- 用户修改自己口令时必须验证旧口令。
	- 不允许修改除自身账号以外的账号的口令（管理员除外）。
 
**
 
第一步
 
**
 先瞅一眼配置界面是啥样的。。俺写的修改密码界面大概跟这个差不多。
 
 然后大段的ctrl+c/ctrl+v，copycopycopy。。
 目标界面是这个样子的：
 
 
第二步
 
**
 稍作修改，先把JS界面写好。比如说：
 1.修改按钮颜色
 
`<div class="pull-right" style="margin-top:30px;">
                    <input type='button' class='btn btn-default' value='服务配置'/>&nbsp;&nbsp;
                    <input type='button' class='btn btn-default' value='服务状态监控'
                           οnclick="javascript:location.href='transList.html';"/>&nbsp;&nbsp;
                    <input type='button' class='btn btn-primary' value='修改登录密码'
                           οnclick="javascript:location.href='modifyKey.html';">&nbsp;&nbsp;
                    <input type='button' class='btn btn-default' value='退出'
                           οnclick='exit()'/>
                </div>`
 
2.删除不需要的按钮和输入框；
 3.添加需要的输入框和“修改密码”按钮：
 
/**
 *需求中有两条：口令输入框不能拷贝、不能明文显示
 *把"input type"设置成password类型
 */
 
<div class="row">

                                        <div class="col-sm-10 col-sm-offset-1">
                                            <div class="form-group label-floating">
                                                <label class="control-label" id="label2">旧密码</label>
                                                <input type="password" class="form-control" id="oldPassword">
                                            </div>
                                        </div>
                                        <div class="col-sm-10 col-sm-offset-1">
                                            <div class="form-group label-floating">
                                                <label class="control-label" id="label10">新密码</label>
                                                <input type="password" class="form-control" id="newPassword">
                                            </div>
                                        </div>
                                        <div class="col-sm-10 col-sm-offset-1">
                                            <div class="form-group label-floating">
                                                <label class="control-label" id="label11">确认新密码</label>
                                                <input type="password" class="form-control" id="confirmNewPassword">
                                            </div>
                                        </div>
                                        <div class="col-sm-10 col-sm-offset-1">
                                            <button type="button" onclick="modifyPassword();" class="btn btn-primary">修改密码</button>
                                        </div>
                                    </div>
 
**
 
第三步
 
**
 完成后端修改密码的逻辑，先把代码贴出来：
 
@LogExecution
    @ResponseBody
    @RequestMapping(value = "/modifyPassword", method = {RequestMethod.POST})
    public ModifyPasswordResponse modifyPassword(@RequestBody ModifyPasswordRequest request)
    {
        String newPassword = request.getNewPassword();
        String confirmNewPassword = request.getConfirmNewPassword();
        String oldPassword = request.getOldPassword();
        int length = newPassword.length();



        ModifyPasswordResponse response = new ModifyPasswordResponse();


        /**
         * 判断两次是否输入旧密码、旧密码是否正确
         */
        if (StringUtils.isBlank(oldPassword))
        {
            throw new BusinessException(107005,"旧密码为空");
        }

        if (!oldPassword.equals(DASASEEncryptUtil.decryptData(masProperties.getConfigPassword(), DASASEEncryptUtil.SECRETKEY)) )
        {
            throw new BusinessException(107006,"旧密码输入错误");
        }

        /**
         * 判断新密码是否为空、两次修改密码是否一致
         */
        if (StringUtils.isBlank(newPassword))
        {
            throw new BusinessException(107000,"新密码为空");
        }

        if (StringUtils.isBlank(confirmNewPassword))
        {
            throw new BusinessException(107001,"未输入确认新密码");
        }

        if (!newPassword.equals(confirmNewPassword))
        {
            throw new BusinessException(107002,"两次新密码输入不一致！");
        }

        /**
         * 判断密码是否过短(不低于5位）
         */
        if (length < 6)
        {
            throw new BusinessException(107003,"新密码长度过短");
        }


        /**
         * 判断密码是否有大小写区分
         */
        int lowerNum = 0;
        int upperNum = 0;
        for (int i = 0; i < length ; i++ ) {

            char passwordCh = newPassword.charAt(i);

            if (Character.isLowerCase(passwordCh)) {

                lowerNum++;

            }

            if (Character.isUpperCase(passwordCh)) {

                upperNum++;

            }
        }

        if (lowerNum == 0 || upperNum == 0){

            throw new BusinessException(107004, "新密码需要大小写");

        }


        String pwd = DASASEEncryptUtil.encryptData(newPassword, DASASEEncryptUtil.SECRETKEY);
        request.setNewPassword(pwd);
        Properties properties = saveProperties(request);
        refreshPassword(properties);

        return response;
    }
 
代码说明：依次进行旧密码是否输入正确、两次输入新密码是否一致、新密码长度验证、复杂度验证等验证。每一次如果判断出不符合要求，就会抛出异常，返回一个错误码。前端有对应的result.code可以返回弹窗消息，代码如下：
 

<script>

    function modifyPassword() {
        var oldPassword = $("#oldPassword").val();
        var newPassword = $("#newPassword").val();
        var confirmNewPassword = $("#confirmNewPassword").val();
        var aoData = {
            "oldPassword":oldPassword,
            "newPassword" : newPassword,
            "confirmNewPassword" : confirmNewPassword
        };
        console.log(aoData)
        $.ajax({
            url: "/api/modifyPassword",
            data: JSON.stringify(aoData),
            type: 'POST',
            contentType: 'application/json;charset=UTF-8',
            success: function (result) {
                if (result.resultCode == 0)
                {
                    alert("修改成功！");
                    window.location.href = "/login.html";
                }

                //判断是否输入旧密码、旧密码是否正确
                if(result.resultCode == 107005){
                    alert("旧密码不能为空");
                    return;
                }
                if (result.resultCode == 107006){
                    alert("旧密码输入错误！");
                    return;
                }

                //判断两次新密码是否为空、两次修改密码是否一致
                if (result.resultCode == 107000)
                {
                    alert("新密码不能为空");
                    $("#label10").css("color", "red");
                    return;
                }

                if (result.resultCode == 107001)
                {
                    alert("请确认新密码");
                    $("#label11").css("color", "red");
                    return;
                }

                if (result.resultCode == 107002)
                {
                    alert("两次密码输入不一致！");
                    $("#label10").css("color", "red");
                    $("#label11").css("color", "red");
                    return;
                }

                //判断密码是否过短(不低于5位）
                if (result.resultCode == 107003)
                {
                    alert("密码长度过短");
                    return;
                }

                //判断新密码复杂度是否符合要求
                if (result.resultCode == 107004)
                {
                    alert("密码必须为数字、大小写字母、符号的组合且长度不得少于6位");
                    return;
                }
                    }
                })
            }
</script>

一、修改密码效果图
 
 二、编写思路
 将登录用户的Id保存到session中，获取session的用户id，由此可以查出用户名和密码
 三、前段代码layui
 js代码
 
//修改密码操作
		$(document).off("click", "#showIndexUpdatePW").on("click", "#showIndexUpdatePW", function () {
			var showContent = $('#showIndexUpdatePWContent').html();
			$('#showIndexUpdatePWContent').html("");
			layer.open({
				type: 1,
				id: 'showLayui',
				title: '修改密码',
				content: showContent, //这里content是一个DOM，注意：最好该元素要存放在body最外层，否则可能被其它的相对元素所影响
				area: '600px',
				btn: ['确定', '取消'],
				btnAlign: 'c',
				success: function (layero, index) {//打开层之后可执行的回调
					layui.use(['form', 'layer'], function () {
						var form = layui.form;
						var layer = layui.layer;

						form.render();  //重新渲染表单
					});
				},
				yes: function (index, layero) { //确定按钮
					var con = {};
					//con.userId = userId.id;
					con.sysOldPWInp = $("#sysOldPWInp").val();
					con.sysNewPWInp = $("#sysNewPWInp").val();
					con.sysConPW = $("#sysConfirmPWInp").val();
					
					var msgArr = ["原密码不能为空", "新密码不能为空", "确认密码不能为空"];  //提示语集合
					var clsArr = ["#sysOldPWInp", "#sysNewPWInp", "#sysConfirmPWInp"];  //id集合
					var validateFlag = until.validate(msgArr, clsArr); //非空验证 需要引入工具js文件until
					if (validateFlag) {
						layer.msg(validateFlag, { anim: 6, time: 1500 });
						return;
					};
					var numFlag = checkInpNum(clsArr); 
					//检查长度是否小于6
					if (numFlag) {
						layer.msg(numFlag, { anim: 6, time: 1500 });
						return;
					};

					$.ajax({
						url: contextPath + "/account/updatePassWord",
						dataType: 'json',
						type: 'post',
						async: false,
						data: con,
						complete: function (XHR, TS) {
							var returnObj = eval('(' + XHR.responseText + ')');
							if (returnObj.code != 200) {
								layer.msg(returnObj.msg, { anim: 6, time: 1500 });
							} else {
								layer.msg(returnObj.msg, { icon: 1, time: 1500 });
								layer.close(index);
								window.setTimeout(function () {
									window.location.href = contextPath + "/logOut";
								}, 1000);

							}
						}
					});

				},
				end: function () { //只要层被销毁了，end都会执行
					$('#showIndexUpdatePWContent').html(showContent);
				}

			});
		});
 
html代码
 
<div class="layuiWindownContent">
			<div class="layui-form" lay-filter="indexUPdatePWFrom">
				<div class="layui-form-item">
					<label class="layui-form-label">原密码<font color="red">*</font></label>
					<div class="layui-input-block">
						<input type="password" id="sysOldPWInp" name="sysOldPWInp"
							lay-verify="pass" placeholder="请填写原密码" autocomplete="off"
							class="layui-input" maxlength="14">
					</div>
				</div>
				<div class="layui-form-item">
					<label class="layui-form-label">新密码<font color="red">*</font></label>
					<div class="layui-input-block">
						<input type="password" id="sysNewPWInp" name="sysNewPWInp"
							placeholder="请填写新密码" autocomplete="off" class="layui-input"
							maxlength="14">
					</div>
				</div>
				<div class="layui-form-item">
					<label class="layui-form-label">确认密码<font color="red">*</font></label>
					<div class="layui-input-block">
						<input type="password" id="sysConfirmPWInp" name="sysConfirmPWInp"
							placeholder="请填写确认密码" autocomplete="off" class="layui-input"
							maxlength="14">
					</div>
				</div>
			</div>
		</div>
 
四、后台代码
 
controller层
 
// 修改密码
	@RequestMapping("/updatePassWord")
	@ResponseBody
	public RetKit updatePassWord(HttpServletRequest request) {
		AccountAuthentic account = (AccountAuthentic) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
		Integer accountId = account.getAccountId();
		String oldpwd = request.getParameter("sysOldPWInp");
		String newPWInp = request.getParameter("sysNewPWInp");
		String conPW = request.getParameter("sysConPW");
		RetKit retKit = accountService.updataPwd(accountId, oldpwd, newPWInp,conPW
		if(retKit.success()) {
			// 清除session
			Enumeration<String> em = request.getSession().getAttributeNames();
			while (em.hasMoreElements()) {
				request.getSession().removeAttribute(em.nextElement().toString());
			}
			request.getSession().invalidate();
		}
		return retKit;
	}
 
service层
 
public RetKit updataPwd(Integer id, String oldP, String newP,String conP) {
		Optional<Account> user = accountRepository.findById(id);
		Account account = user.get();
		if (user!=null) {
			if (!HashKit.md5(oldP).equals(user.get().getPassword())) {
				return RetKit.fail("旧密码错误");
			}
			if (!newP.equals(conP)) {
				return RetKit.fail("新密码与确认密码不一致");
			}
			if(HashKit.md5(newP).equals(user.get().getPassword())) {
				return RetKit.fail("新密码与旧密码相同，请重新输入");
			}
			account.setPassword(HashKit.md5(newP));
			try {
				accountRepository.save(account);
			} catch (Exception e) {
				return RetKit.fail("网络异常");
			}
			
			return RetKit.ok("修改成功");
			
		}
		return RetKit.fail("用户登陆失效");
	}

1.实现修改密码界面，主要是让用户在必要时修改自己的原始密码，从而保证用户信息的安全性。
 2.界面效果如下：效果如下：
 
 
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_modify_psw"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:background="@drawable/register_bg"
    tools:context="itcast.cn.boxuegu.activity.ModifyPswActivity">
    <include layout="@layout/main_title_bar"/>
    <EditText
        android:id="@+id/et_original_psw"
        android:layout_width="fill_parent"
        android:layout_height="48dp"
        android:layout_gravity="center_horizontal"
        android:layout_marginLeft="35dp"
        android:layout_marginRight="35dp"
        android:layout_marginTop="35dp"
        android:background="@drawable/register_user_name_bg"
        android:drawableLeft="@drawable/psw_icon"
        android:drawablePadding="10dp"
        android:gravity="center_vertical"
        android:hint="请输入原始密码"
        android:inputType="textPassword"
        android:paddingLeft="8dp"
        android:textColor="#000000"
        android:textColorHint="#a3a3a3"
        android:textSize="14sp"
        />
    <EditText
        android:id="@+id/et_new_psw"
        android:layout_width="fill_parent"
        android:layout_height="48dp"
        android:layout_gravity="center_horizontal"
        android:layout_marginLeft="35dp"
        android:layout_marginRight="35dp"
        android:background="@drawable/register_user_name_bg"
        android:drawableLeft="@drawable/psw_icon"
        android:drawablePadding="10dp"
        android:gravity="center_vertical"
        android:hint="请输入新密码"
        android:inputType="textPassword"
        android:paddingLeft="8dp"
        android:textColor="#000000"
        android:textColorHint="#a3a3a3"
        android:textSize="14sp"
        />
    <EditText
        android:id="@+id/et_new_psw_again"
        android:layout_width="fill_parent"
        android:layout_height="48dp"
        android:layout_gravity="center_horizontal"
        android:layout_marginLeft="35dp"
        android:layout_marginRight="35dp"
        android:background="@drawable/register_user_name_bg"
        android:drawableLeft="@drawable/psw_icon"
        android:drawablePadding="10dp"
        android:gravity="center_vertical"
        android:hint="请再次输入新密码"
        android:inputType="textPassword"
        android:paddingLeft="8dp"
        android:textColor="#000000"
        android:textColorHint="#a3a3a3"
        android:textSize="14sp"
        />
    <Button
        android:id="@+id/btn_save"
        android:layout_width="fill_parent"
        android:layout_height="40dp"
        android:layout_marginLeft="35dp"
        android:layout_marginRight="35dp"
        android:layout_marginTop="15dp"
        android:layout_gravity="center_horizontal"
        android:background="@drawable/register_selector"
        android:text="保存"
        android:textColor="@android:color/white"
        android:textSize="18sp"
        />
</LinearLayout>

 
3.在实现修改密码界面逻辑代码中，主要用于输入原始密码，新密码，再次修改新密码。输入的原始密码与从SharedPrefenences中读取的原始密码必须一致，输入的新密码与原始密码不能相同，再次输入的新密码与与输入的新密码必须相同。以上条件都符合之后，点击“保存”按钮提示设置成功，同时修改Sharedference中的原始密码。
 
package itcast.cn.boxuegu.activity;

import android.content.Intent;
import android.content.SharedPreferences;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import itcast.cn.boxuegu.R;
import itcast.cn.boxuegu.utils.AnalysisUtils;
import itcast.cn.boxuegu.utils.MD5Utils;

public class ModifyPswActivity extends AppCompatActivity {

    private TextView tv_main_title;
    private TextView tv_back;
    private EditText et_original_psw;
    private EditText et_new_psw;
    private EditText et_new_psw_again;
    private Button btn_save;
    private String originalPsw;
    private String newPsw;
    private String newPswAgain;
    private String userName;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_modify_psw);
        init();
        userName = AnalysisUtils.readLoginUserName(this);
    }
    //  获取界面控件并处理相关控件的处理事件
    private void init() {
        tv_main_title = (TextView) findViewById(R.id.tv_main_title);
        tv_main_title.setText("修改密码");
        tv_back = (TextView) findViewById(R.id.tv_back);
        tv_back.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ModifyPswActivity.this.finish();//关闭当前界面
            }
        });
        et_original_psw = (EditText) findViewById(R.id.et_original_psw);
        et_new_psw = (EditText) findViewById(R.id.et_new_psw);
        et_new_psw_again = (EditText) findViewById(R.id.et_new_psw_again);
        btn_save = (Button)  findViewById(R.id.btn_save);
        btn_save.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                getEditString();
                if (TextUtils.isEmpty(originalPsw)){
                    Toast.makeText(ModifyPswActivity.this,"请输入原始密码",Toast.LENGTH_SHORT).show();
                }else if (!MD5Utils.md5(originalPsw).equals(readPsw())){
                    Toast.makeText(ModifyPswActivity.this,"输入的密码与原始密码不一致",Toast.LENGTH_SHORT).show();
                }else if (MD5Utils.md5(newPsw).equals(readPsw())){
                    Toast.makeText(ModifyPswActivity.this,"输入的新密码与原始密码不能一致",Toast.LENGTH_SHORT).show();
                }else if (TextUtils.isEmpty(newPsw)){
                    Toast.makeText(ModifyPswActivity.this,"请输入新密码",Toast.LENGTH_SHORT).show();
                }else if (TextUtils.isEmpty(newPswAgain)){
                    Toast.makeText(ModifyPswActivity.this,"请再次输入新密码",Toast.LENGTH_SHORT).show();
                }else if (!newPsw.equals(newPswAgain)){
                    Toast.makeText(ModifyPswActivity.this,"两次输入的新密码不一致",Toast.LENGTH_SHORT).show();
                }else{
                    Toast.makeText(ModifyPswActivity.this,"新密码设置成功",Toast.LENGTH_SHORT).show();
                    //修改登录成功后保存在SharedPreferences中的密码
                    modifyPsw(newPsw);
                    Intent intent = new Intent(ModifyPswActivity.this,LoginActivity.class);
                    startActivity(intent);
                    ModifyPswActivity.this.finish();//关闭当前界面
                    SettingActivity.instance.finish();//关闭设置界面
                }
            }
        });

    }
    //修改登录成功后保存在SharedPreferences中的密码
    private void modifyPsw(String newPsw) {
        String md5Psw = MD5Utils.md5(newPsw);//对新密码进行加密
        SharedPreferences sp = getSharedPreferences("loginInfo",MODE_PRIVATE);
        SharedPreferences.Editor editor = sp.edit();//获取编辑器
        editor.putString(userName,md5Psw);
        editor.commit();

    }
    //从SharedPreferences中读取原始密码
    private String readPsw() {
        SharedPreferences sp = getSharedPreferences("loginInfo",MODE_PRIVATE);
        String spPsw = sp.getString(userName,"");
        return spPsw;

    }

    //h获取控件上的字符串
    private void getEditString() {
        originalPsw = et_original_psw.getText().toString().trim();
        newPsw = et_new_psw.getText().toString().trim();
        newPswAgain = et_new_psw_again.getText().toString().trim();
    }
}

 
passwd命令修改密码
 

  

  

 
 
 介绍 (Introduction)
 
 
Linux passwd command changes a user’s password. A user can only change his/her own password but the root/superuser may change any user’s password.
 
 Linux passwd命令更改用户密码。 用户只能更改自己的密码，但root / superuser可以更改任何用户的密码。 
 
 
Let’s look at the Linux man page to understand the usage of this command. This is done by typing in the following command:
 
 让我们看一下Linux手册页，以了解此命令的用法。 通过键入以下命令来完成此操作： 
 
 

 
 
 
$ man passwd
 
 Linux中的密码 (Passwords in Linux)
 
 
The traditional method of storing passwords in a UNIX based system involved storing the information in /etc/passwd file.
 
 在基于UNIX的系统中存储密码的传统方法包括将信息存储在/ etc / passwd文件中。 
 
 
This file, however, was accessed by many programs and hence posed a security risk.
 
 但是，该文件已被许多程序访问，因此存在安全风险。 
 
 
Nowadays, /etc/passwd file only contains essential user info required at login and authentication.
 
 如今， /etc/passwd文件仅包含登录和身份验证所需的基本用户信息。 
 
 
The actual encrypted version of the password is stored in a separate file – /etc/shadow. This file can only be accessed by the root user.
 
 密码的实际加密版本存储在单独的文件/etc/shadow 。 该文件只能由root用户访问。 
 
 

  

  

 
 
/etc/passwd file looks as follows:
   

    
    
passwd file contents
   
Each line of the file contains general user information about a certain program or user. The fields are separated by :.
 These field are as follow:
   
Username (upto 8 characters)
x to denote the password, which is stored in the /etc/shadow file in encrypted format.
Numeric User ID.
Numeric Group ID.
Full username.
Path of the home directory.
Path of the preferred shell. ("/bin/bash")
 /etc/passwd文件如下所示： 
   
 
    
 passwd文件内容 
 
   
 
 文件的每一行都包含有关某个程序或用户的一般用户信息。 这些字段用:分隔。 
 这些字段如下： 
 
   
 用户名（最多8个字符） 
 x表示密码，该密码以加密格式存储在/etc/shadow文件中。 
 数字用户ID。 
 数字组ID。 
 完整的用户名。 
 主目录的路径。 
 首选外壳的路径。 （ "/bin/bash" ） 
 
/etc/shadow file looks as follows (requires root access):
   

    
    
shadow file contents
   
This file contains account and password information. The fields are separated by :.
The fields corresponding user account information are as follow:
   
Username (upto 8 characters)
The second field contains the encrypted password and is divided into sub-fields (separated by $ character).The first sub-field denotes the encryption algorithm used:
Second sub-field contains the salt value used during the encryption process. Third sub-field contains the encrypted password.
Number of days since the password was changed.
Number of days before password may be changed (0 indicates it may be changed at any time).
Number of days after which password must be changed.
Number of days prior to the expiration of the password, that the user must be warned.
Number of days after which the account is disabled after a password has expired.
Days since Jan 1, 1970 that the account has been inactive or disabled.
Reserve field for extra information.
 /etc/shadow文件如下所示（需要root访问）： 
   
 
    
    
 影子文件内容 
 
   
 
 此文件包含帐户和密码信息。 这些字段用:分隔。 
 
 对应于用户帐户信息的字段如下： 
 
   
 用户名（最多8个字符） 
 第二个字段包含加密的密码，并分为多个子字段（以$字符分隔）。第一个子字段表示使用的加密算法： 
 第二个子字段包含加密过程中使用的盐值。 第三子字段包含加密的密码。 
 
 更改密码以来的天数。 
 可以更改密码的天数（0表示可以随时更改）。 
 必须更改密码的天数。 
 密码到期前的天数，必须警告用户。 
 密码过期后帐户被禁用的天数。 
 自1970年1月1日以来，该帐户已无效或已禁用的天数。 
 保留字段以获取更多信息。 
 
 
 Linux password命令语法 (Linux password Command Syntax)
 
 
$ passwd [options]... [LOGIN]...
 
 1.更改当前用户的密码 (1. Changing Current User’s password)
 
 

  
  
Typing Passwd Comand
  
 输入Passwd Comand 
 
 
 
Typing passwd prompts the user to first enter the current password. User only gets one chance the type in the correct password. If the password entered is incorrect or cannot be changed at the time, the terminal displays an error and exits.

 
 键入passwd会提示用户首先输入当前密码。 用户只有一次输入正确密码的机会。 如果输入的密码不正确或当时无法更改，则终端显示错误并退出。 
 
 

  
  
Passwd Authentication Error
  
 密码验证错误 
 
 
 

  

  

 
 
Once the password is entered, it is encrypted and matched against the stored encrypted password. The user is then prompted to enter the new password twice. Both passwords need to be sufficiently complex and match each other in order to be accepted as valid passwords.
 
 输入密码后，它将被加密并与存储的加密密码匹配。 然后提示用户两次输入新密码。 两个密码都必须足够复杂并且彼此匹配，才能被接受为有效密码。 
 
 

  
  
Entering New Password
  
 输入新密码 
 
 
 
An error is displayed if the new password resembles the old one closely.
 
 如果新密码与旧密码非常相似，则会显示错误。 
 
 
Once every criterion is met, the password for the current user is changed successfully.
 
 一旦满足每个条件，就可以成功更改当前用户的密码。 
 
 

  
  
New Password Set
  
 新密码集 
 
 
 
 2.更改其他用户的密码 (2. Changing another User’s password)
 
 
The following command is used to change the password of another user:
 
 以下命令用于更改其他用户的密码： 
 
 
$ sudo passwd adam
 
Since root access is required to change passwords of other users, the terminal prompts the user to enter the password. The process to change the password for other users is same as the current user.
 
 由于需要root用户访问权限才能更改其他用户的密码，因此终端会提示用户输入密码。 更改其他用户密码的过程与当前用户相同。 
 
 
 Linux passwd命令选项 (Linux passwd Command Options)
 
 
-d or –delete option deletes the user’s password. It sets the user’s account passwordless.
 -d或–delete选项删除用户密码。 它将用户帐户设置为无密码。 
-e or –expire option immediately expires user’s password. This can force them to change their password.
 -e或–expire选项将立即使用户密码失效。 这可以迫使他们更改密码。 
-h or –help option displays the help message and exits.
 -h或–help选项显示帮助消息并退出。 
-l or –lock option locks the password of the named account by adding a ‘!’ at the beginning of the password. This prevents the encrypted hash to be successfully matched against stored hash. Users with locked passwords cannot change their passwords.
 -l或–lock选项通过添加“！”来锁定命名帐户的密码。 在密码开头。 这样可以防止将加密的哈希与存储的哈希成功匹配。 密码锁定的用户无法更改其密码。 
-i [INACTIVE_DAYS]or –inactive [INACTIVE_DAYS] option disables an account after the password has expired for a number of days.
 -i [INACTIVE_DAYS]或–inactive [INACTIVE_DAYS]选项会在密码过期数天后禁用帐户。 

   
   
Passwd Inactive Option
   
 密码无效选项 
 
  
  
-n [MIN_DAYS] or –mindays [MIN_DAYS] option sets minimum number of days between password changes. A value of 0 suggests a password can be changed anytime.
 -n [MIN_DAYS]或–mindays [MIN_DAYS]选项设置两次密码更改之间的最少天数。 值为0表示可以随时更改密码。 

   
   
Passwd Mindays Option Example
   
 Passwd Mindays选项示例 
 
  
  
-r [REPOSITORY] or –repository [REPOSITORY] option sets password for a particular repository.
 -r [REPOSITORY]或–repository [REPOSITORY]选项设置特定存储库的密码。 
-S or –status displays account status information.
 -S或–status显示帐户状态信息。 

   
   
passwd status option example
   
 passwd状态选项示例 
 
  
  
The output is split into different fields as shown above. The first field shows the name of the current user.
  
 如上所示，输出分为多个字段。 第一个字段显示当前用户的名称。 
 
  
The second field shows if the user has a usable password (P), locked password (L) or no password (NP).
  
 第二个字段显示用户是否具有可用密码（ P ），锁定密码（ L ）或无密码（ NP ）。 
 
  
The third field shows the last date of the password change. The next few fields show the minimum age, maximum age, warning period and inactivity period of password respectively.
  
 第三个字段显示密码更改的最后日期。 接下来的几个字段分别显示密码的最小期限，最大期限，警告期限和不活动期限。 
 
  
-a or –all option shows the status for all users. It can only be used with -S.
 -a或–all选项显示所有用户的状态。 它只能与-S一起使用。 
-u or –unlock options unlocks a locked password and sets to to it’s previous value.
 -u或–unlock选项可解锁锁定的密码，并将其设置为先前的值。 
-w [WARN_DAYS] or –warndays [WARN_DAYS] option sets the number of days a warning is displayed before the password needs to be changed.
 -w [WARN_DAYS]或–warndays [WARN_DAYS]选项设置在需要更改密码之前显示警告的天数。 

   
   
passwd warndays options example
   
 passwd warndays选项示例 
 
  
  
-x or –maxdays [MAX_DAYS] option sets the maximum number of days a password remains valid. After that, password needs to be changed.
 -x或–maxdays [MAX_DAYS]选项设置密码保持有效的最大天数。 之后，需要更改密码。 

   
   
passwd maxdays option example
   
 passwd maxdays选项示例 
 
  
 
 
 结论 (Conclusion)
 
 
Linux passwd command is a basic but important command. It can be used to handle essential user information and authentication upon logging in the system and performing various tasks in the terminal like installing packages and accessing certain directories.
 
 Linux passwd命令是一个基本但重要的命令。 它可以用于在登录系统并在终端中执行各种任务（如安装软件包和访问某些目录）时处理必要的用户信息和身份验证。 
 
 

  
翻译自: https://www.journaldev.com/31647/linux-passwd-command-change-user-password
 
 
passwd命令修改密码