一个玩具程序——测试密码强度(pure C)

替人写的C语言作业…

介绍：

程序名称：
密码强度检测程序

注释风格：
doxygen

测试环境：
linux3.6, gcc4.7
window7, vs2012

已知问题：
1. 算法与参考链接不一致，结果会有差别，详见代码注释。
2. 在vs下可能会编译不通过，将后缀改为cpp就可以了。vs的C编译器实现对C90支持不佳，gcc4.5以上可以正常编译通过。

#ifndef CHECKPASS_H_INCLUDED
#define CHECKPASS_H_INCLUDED

/*!
 * \brief   本程序用于检测密码强度
 * \details 请根据提示输入密码，程序会自动输出对应的强度
 *
 *          程序会根据是否满足一定的条件对密码进行打分，然后区分出档次。
 *          得分最低0分，最高100分；等级分为很弱-弱-一般-好-强-极强几个档次。
 *          判断标准（参考[链接](http://goo.gl/wuQdN):
 *          1. 最低要求包括
 *             * 长度>8位
 *             * 以下四种元素至少有三种：
 *               - 大写英文字母
 *               - 小写英文字母
 *               - 数字
 *               - 特殊符号
 *          2. 加分条件
 *             * 密码总字数  +(次数*4)
 *             * 大写字母数  +(长度-字数)*2 [字数必须>0]
 *             * 小写字母数  +(长度-字数)*2 [同上]
 *             * 数字个数    +(次数*4)
 *             * 特殊符号数  +(次数*6)
 *             * 数字或符号出现在密码中间部分 +(次数*2)
 *             * 达到最低需求 +(次数*2)
 *          3. 减分条件
 *             * 只有字母   -次数
 *             * 只有数字   -次数
 *             * 出现重复单元，对每个重复的字符  -次数*(次数-1) [不计大小写]
 *             * 连续大写字母 -次数*2
 *             * 连续小写字母 -次数*2
 *             * 连续多个数字 -次数*2
 *             * 字母顺序递增/减（三个及以上） -次数*3
 *             * 数字顺序递增/减（三个及以上） -次数*3
 *
 * \author
 * \date 2013-06-22
 * \copyright GNU Public License
 */

/** 字符数目，取char的最大值+1*/
#define CHARNUM 256

/** 强度评价*/
extern const char *g_pPasswordLevel[];

/** 强度枚举*/
typedef enum _PasswordLevel {
    VERYWEEK,
    WEEK,
    AVERAGE,
    GOOD,
    STRONG,
    VERYSTRONG
} PasswordLevel;


/** 计算得分需要的参数*/
typedef struct _RuleParameter {
    int nLength;      ///< 密码长度
    int nUpper;       ///< 大写字母个数
    int nLower;       ///< 小写字母个数
    int nDigit;       ///< 数字个数
    int nSymbol;      ///< 特殊字符个数
    int nMidDigitSymbol; ///< 中间部分的数字或字符个数
    int nRequirement; ///< 达到最低需求的次数
    int RepeatChar[CHARNUM];  ///< 每个字符重复的次数
    int nConsecUpper; ///< 连续大写字母个数
    int nConsecLower; ///< 连续小写字母个数
    int nConsecDigit; ///< 连续数字个数
    int nSequence;     ///< （三个及以上）顺序字母/数字次数
} RuleParameter;

/**
 * \brief 求密码得分
 * \param[in] password 密码
 * \return 得分
 */
int GetPasswordScore(const char *password);

/**
 * \brief 求密码等级
 * \param[in] password 密码得分
 * \return 密码等级
 */
PasswordLevel GetPasswordLevel(int score);


#endif // CHECKPASS_H_INCLUDED

#include "checkPass.h"

#include <stdlib.h>
#include <string.h>
#include <ctype.h>

/** 强度评价*/
const char *g_pPasswordLevel[]= {
    "很弱",
    "弱",
    "一般",
    "好",
    "强",
    "很强"
};

/**
* \defgroup prototypes
* @{
*/

/**
* \brief 负责调用其他计算函数，填充了长度字段
* \param[in] password 密码
* \param[out] rp 待填充的规则参数结构指针
*/
void beginProcess(const char *password,RuleParameter *rp);

/**
* \brief 填充大写、小写、数字、符号及他们的连续值字段
* \param[in] password 密码
* \param[out] rp 待填充的规则参数结构指针
*/
void countNumbers(const char *password,RuleParameter *rp);

/**
* \brief 填充连续递增/减字符的个数字段
* \param[in] password 密码
* \param[out] rp 待填充的规则参数结构指针
*/
void countSeqNumbers(const char *password,RuleParameter *rp);

/**
* \brief 填充重复单元字段
* \param[in] password 密码
* \param[out] rp 待填充的规则参数结构指针
*/
void countRepeat(const char *password, RuleParameter *rp);

/**
* \brief 计算密码得分
* \param[in] rp 已经填充的规则参数结构指针
* \return 得分
*/
int countScore(const RuleParameter *rp);

/** @}*/

PasswordLevel GetPasswordLevel(int score)
{
    if(score<20) {
        return VERYWEEK;
    }
    if(score<40) {
        return WEEK;
    }
    if(score<60) {
        return AVERAGE;
    }
    if(score<80) {
        return STRONG;
    }
    return VERYSTRONG;
}

int GetPasswordScore(const char *password)
{
    RuleParameter rp= {0};
    beginProcess(password,&rp);
    return countScore(&rp);
}

void beginProcess(const char *password,RuleParameter *rp)
{
    if(password==NULL || rp==NULL) return;

    int i,j;

    char *pass_nospace=(char *)malloc(strlen(password)+1);
    char *pass_nospace_lower=(char *)malloc(strlen(password)+1);

    if(!pass_nospace) exit(EXIT_FAILURE);

    for(i=0,j=0; password[i]!='\0'; i++) {
        if(!isspace(password[i])) {
            pass_nospace[j]=password[i];
            pass_nospace_lower[j]=tolower(password[i]);
            ++j;
        }
    }
    pass_nospace[j]='\0';

    rp->nLength=strlen(pass_nospace);

    countRepeat(pass_nospace_lower,rp);
    countNumbers(pass_nospace,rp);
    countSeqNumbers(pass_nospace,rp);

    free(pass_nospace);
    free(pass_nospace_lower);
}

void countRepeat(const char *password, RuleParameter *rp)
{
    if(!password || !rp)return;

    int i;
    for(i=0; i<rp->nLength; i++) {
        ++rp->RepeatChar[password[i]];
    }
}

void countNumbers(const char *password, RuleParameter *rp)
{
    if(!password || !rp)return;

    int i;
    int last_upper_pos=-1;
    int last_lower_pos=-1;
    int last_digit_pos=-1;

    for(i=0; i<rp->nLength; i++) {
        if(isupper(password[i])) {
            if(last_upper_pos!=-1 && last_upper_pos+1==i) {
                ++rp->nConsecUpper;
            }
            last_upper_pos=i;
            ++rp->nUpper;
        } else if(islower(password[i])) {
            if(last_lower_pos!=-1 && last_lower_pos+1==i) {
                ++rp->nConsecLower;
            }
            last_lower_pos=i;
            ++rp->nLower;
        } else if(isdigit(password[i])) {
            if(last_digit_pos!=-1 && last_digit_pos+1==i) {
                ++rp->nConsecDigit;
            }
            if(i>0 && i< rp->nLength-1) {
                ++rp->nMidDigitSymbol;
            }
            last_digit_pos=i;
            ++rp->nDigit;
        } else {
            if(i>0 && i<rp->nLength-1) {
                ++rp->nMidDigitSymbol;
            }
            ++rp->nSymbol;
        }
    }

    if(rp->nLower>0) ++rp->nRequirement;
    if(rp->nUpper>0) ++rp->nRequirement;
    if(rp->nDigit>0) ++rp->nRequirement;
    if(rp->nSymbol>0) ++rp->nRequirement;
}

/**
* \note 注意，此处计算重复数字的算法与参考链接处并不相同！
*       经过反复测试，参考链接中测试算法与其描述并不相符，
*       此处的实现中，字符不能同时被统计在上升序列和下降序列中！
*/
void countSeqNumbers(const char *password,RuleParameter *rp)
{
    if(!password || !rp || rp->nLength<3)return;

    int inc_count=1;
    int dec_count=1;
    int i=1;

    for(; i<rp->nLength; i++) {
        if(isalnum(password[i]) && isalnum(password[i-1])) {
            if(password[i]-password[i-1]==1) {
                if(dec_count<3)++inc_count;
                dec_count=1;
            } else if(password[i]-password[i-1]==-1) {
                if(inc_count<3)++dec_count;
                inc_count=1;
            } else {
                inc_count=dec_count=1;
            }
        } else {
            inc_count=dec_count=1;
        }

        if(inc_count>=3 || dec_count>=3) {
            ++rp->nSequence;
        }
    }
}

int countScore(const RuleParameter *rp)
{
    if(!rp || rp->nLength==0)return 0;

    int score=0;
    int i;
    int n;

    score+=rp->nLength * 4;
    if(rp->nUpper!=0)score+=(rp->nLength - rp->nUpper) *2;
    if(rp->nLower!=0)score+=(rp->nLength - rp->nLower) *2;
    if(rp->nLength!=rp->nDigit)score+=rp->nDigit *4;
    score+=rp->nSymbol *6;
    score+=rp->nMidDigitSymbol *2;
    if(rp->nLength>=8 && rp->nRequirement>=3) {
        score+=(rp->nRequirement+1)*2;
    }

    if(rp->nDigit==rp->nLength || rp->nLower+rp->nUpper==rp->nLength)
        score-=rp->nLength;

    for(i=0; i<CHARNUM; ++i) {
        n=rp->RepeatChar[i];
        if(n>1) {
            score-=n*(n-1);
        }
    }
    score-=rp->nConsecDigit * 2;
    score-=rp->nConsecLower *2;
    score-=rp->nConsecUpper *2;
    score-=rp->nSequence *3;

    if(score<0) score=0;
    if(score>100) score=100;
    return score;
}

#include <stdio.h>
#include "checkPass.h"

/**缓冲区最大长度*/
# define BUFFERLEN 1000

int main()
{
    char password[BUFFERLEN];
    int score;
    PasswordLevel level;

    while(1) {
        printf("请输入密码：\n");
        if(fgets(password,BUFFERLEN,stdin)==NULL)continue;

        score=GetPasswordScore(password);
        level=GetPasswordLevel(score);

        printf("该密码得分为 %d, 评价为 %s\n",score,g_pPasswordLevel[level]);
    }
    return 0;
}