目次
- サンプル・プログラム
- 使用ライブラリ
- リソースの準備
- プログラム製作の背景
- 解説：指定した文字列が数字だけかどうか
- 解説：指定した文字列が英数n文字以下かどうか
- 解説：指定した文字列が辞書に存在するかどうか
- 解説：指定した文字列が記号を含まないかどうか
- 解説：指定した文字列に連続した文字を含むかどうか
- 解説：総当たりで解読するときの時間
- 解説：パスワードの強度を求める
- 解説：指定した文字列が数字だけかどうか
- 解説：辞書ファイルを空にする
- 解説：辞書ファイルを指定したメモリに読み込む
- 解説：指定したハッシュ値が指定したメモリになければ追加する
- 解説：指定したメモリの内容を辞書ファイルに書き込む
- 解説：ブラックリスト・ファイルを読み込んで辞書ファイルに追加
- 解説：辞書ファイルに登録されているパスワード数
- 同梱のブラックリスト辞書について
- 参考サイト
サンプル・プログラム
| passwordStrength.msi | インストーラ |
| bin/passwordStrength.exe | 実行プログラム本体（GUI版） |
| bin/pswst.exe | 実行プログラム本体（CUI版） |
| bin/etc/help.chm | ヘルプ・ファイル |
| sour/passwordStrength.cpp | ソース・プログラム |
| sour/resource.h | リソース・ヘッダ |
| sour/resource.rc | リソース・ファイル（GUI版） |
| sour/resource2.rc | リソース・ファイル（CUI版） |
| sour/application.ico | アプリケーション・アイコン（GUI版） |
| sour/application2.ico | アプリケーション・アイコン（CUI版） |
| sour/passwords.txt | ブラックリスト辞書（サンプル） |
| sour/makefile | GUI版ビルド |
| sour/makefile_cmd | CUI版ビルド |
| バージョン | 更新日 | 内容 |
|---|---|---|
| 1.0.5 | 2024/08/31 | ブラックリスト辞書の強化，使用ライブラリ更新 |
| 1.0.4 | 2024/05/04 | DECODE_TIME の値を改訂 |
| 1.0.3 | 2024/04/20 | 使用ライブラリ更新 |
| 1.0.2 | 2023/11/23 | 辞書ファイルを強化，使用ライブラリ更新 |
| 1.0.1 | 2023/07/23 | 使用ライブラリ更新，bug-fix |
使用ライブラリ
リソースの準備
ResEdit を起動し、resource.rc を用意する。
Eclipse に戻り、ソース・プログラム "passwordStrength.cpp" を追加する。
リンカー・フラグを -s -mwindows -static -lstdc++ -lgcc -lole32 -lcrypto -lboost_program_options-mt -lpthread -lwinpthread" に設定する。
また、CUI版をビルドするために、構成 CMD を追加し、リンカー・フラグを -s -static -lstdc++ -lgcc -lole32 -lcrypto -lboost_program_options-mt -lpthread に設定する。
MSYS2 コマンドラインからビルドするのであれば、"makefile" と "makefile_cmd" を利用してほしい。
プログラム製作の背景
NIST（National Institute of Standards and Technology；米国立標準技術研究所）は、セキュリティ文書「NIST Special Publication 800-63B」の「5.1.1 記憶シークレット」に、パスワードの要件として次の項目を挙げている。
- 長いパスワード(8文字以上、最長64文字)
- 表示可能文字のASCII,Unicodeや空白の使用を許可
- Password1やqwerty123などの違反したパスワード、辞書単語をブラックリストに設定
- aaaa1234や123456などの連続した同じ文字の使用を制限
- 強固なパスワードチェッカーを使用
- 連続で認証失敗した場合に強制的にアカウントをロック
- パスワードの入力でペースト機能の使用を許可
- パスワードの他、別の種類による二要素認証を強制
この要件の1～4を実装した「5．パスワードチェッカー」を作ろうと考えた。
解説：指定した文字列が数字だけかどうか
538: /**
539: * 指定した文字列が数字だけかどうかを求める．
540: * @param string str 文字列
541: * @return bool TRUE：数字だけである／FALSE：ではない
542: */
543: bool isNumbersOnly(string str) {
544: regex re("^[0-9]+$");
545: return regex_match(str, re);
546: }
解説：指定した文字列が英数字だけかどうか
548: /**
549: * 指定した文字列が英数字だけかどうかを求める．
550: * @param string str 文字列
551: * @return bool TRUE：英数字だけである／FALSE：ではない
552: */
553: bool isAlphanumeric(string str) {
554: regex re("^[A-Z|a-z|0-9]+$");
555: return regex_match(str, re);
556: }
解説：指定した文字列が辞書に存在するかどうか
558: /**
559: * 指定した文字列が辞書に存在するかどうかを求める．
560: * 指定した文字列を小文字に統一して辞書ファイルと比較する．
561: * @param string str 文字列
562: * @return bool TRUE：存在する／FALSE：存在しない、またはエラー
563: */
564: bool inDictionary(string str) {
565: unsigned char s1[SIZE_BUFF + 1];
566: unsigned char s2[SIZE_BUFF + 1];
567:
568: string s0 = str;
569: //小文字に統一する
570: transform(s0.begin(), s0.end(), s0.begin(), ::tolower);
571: size_t len = s0.length();
572: //MD5ハッシュ値をs1に代入する．
573: MD5((const unsigned char *)s0.c_str(), len, (unsigned char *)s1);
574:
575: // printDictionary((Digest *)s1);
576: // cout << endl;
577:
578: //カーソルを砂時計に
579: HCURSOR cur = SetCursor(LoadCursor(NULL, IDC_WAIT));
580:
581: //辞書ファイルに含まれているかどうか探す．
582: bool ret = FALSE;
583: const char *dicname = getDictionaryName();
584: FILE *infp = fopen(dicname, "rb");
585: if (infp == NULL) {
586: ErrorMessage = "辞書ファイルが見当たりません";
587: cout << ErrorMessage << endl;
588: return FALSE;
589: }
590: for (size_t i = 0; i < MAX_WORDS; i++) {
591: if (feof(infp)) break;
592: fread(s2, sizeof(Digest), 1, infp);
593:
594: // printDictionary((Digest *)s2);
595: // cout << endl;
596:
597: if (memcmp(s1, s2, sizeof(Digest)) == 0) {
598: ret = TRUE;
599: break;
600: }
601: }
602: fclose(infp);
603:
604: //カーソルを元に戻す
605: SetCursor(cur);
606:
607: return ret;
608: }
入力されたパスワードを、MD5でハッシュ化し、ブラックリスト辞書にあるかどうかを突合する。ブラックリスト辞書は固定長バイナリファイルなので、forループで回して合致するハッシュ値があるかどうかを調べている。
解説：指定した文字列が記号を含まないかどうか
610: /**
611: * 指定した文字列が記号を含むかどうかを返す．
612: * @param string str 文字列
613: * @return bool TRUE：記号を含んでいない／FALSE：含んでいる
614: */
615: bool isContainNoSymbol(string str) {
616: regex re("^[A-Z|a-z|0-9]+$");
617: return regex_match(str, re);
618: }
解説：指定した文字列に連続した文字を含むかどうか
620: /**
621: * 指定した文字列に連続した文字を含むかどうかを求める．
622: * @param string str 文字列
623: * @return bool true：連続した文字を含む／false：含まない
624: */
625: bool isSeqCharacters(string str) {
626: const char *ptr = str.c_str();
627: bool ret = FALSE;
628: size_t len = str.length();
629: if (len > 1) {
630: for (size_t i = 1; i < len; i++) {
631: if (ptr[i] == ptr[i - 1]) {
632: ret = TRUE;
633: break;
634: }
635: }
636: }
637: return ret;
638: }
解説：総当たりで解読するときの時間
640: /**
641: * 指定したパスワードを総当たりで解読するときの時間を求める．
642: * @param string psw パスワード
643: * @return string 解読時間
644: */
645: string calcDecodeTime(string psw) {
646: //文字種と桁数を求める．
647: regex re1("^[0-9]+$");
648: regex re2("^[A-Z]+$");
649: regex re3("^[0-9|A-Z]+$");
650: regex re4("^[a-z]+$");
651: regex re5("^[0-9|a-z]+$");
652: regex re6("^[A-Z|a-z]+$");
653: regex re7("^[0-9|A-Z|a-z]+$");
654: size_t num, len;
655: if (regex_match(psw, re1)) {
656: num = 10;
657: } else if (regex_match(psw, re2)) {
658: num = 26;
659: } else if (regex_match(psw, re3)) {
660: num = 36;
661: } else if (regex_match(psw, re4)) {
662: num = 26;
663: } else if (regex_match(psw, re5)) {
664: num = 36;
665: } else if (regex_match(psw, re6)) {
666: num = 52;
667: } else if (regex_match(psw, re7)) {
668: num = 62;
669: } else {
670: num = 86;
671: }
672: len = psw.length();
673:
674: //解読時間を計算する．
675: static char buff[SIZE_BUFF + 1];
676: double sec = (double)pow(num, len) * DECODE_TIME;
677: if (sec <= 1) {
678: snprintf(buff, sizeof(buff), "1秒以下で解読できる．");
679: } else if (sec < 60) {
680: snprintf(buff, sizeof(buff), "解読に約%.0f秒かかる．", sec);
681: } else if (sec < (double)60 * 60) {
682: snprintf(buff, sizeof(buff), "解読に約%.0f分かかる．", sec / 60);
683: } else if (sec < (double)60 * 60 * 24) {
684: snprintf(buff, sizeof(buff), "解読に約%.0f時間かかる．", sec / (60 * 60));
685: } else if (sec < (double)60 * 60 * 24 * 30) {
686: snprintf(buff, sizeof(buff), "解読に約%.0f日かかる．", sec / (60 * 60 * 24));
687: } else if (sec < (double)60 * 60 * 24 * 30 * 12) {
688: snprintf(buff, sizeof(buff), "解読に約%.0fヶ月かかる．", sec / (60 * 60 * 24 * 30));
689: } else if (sec < (double)60 * 60 * 24 * 30 * 12 * 1000) {
690: snprintf(buff, sizeof(buff), "解読に約%.0f年かかる．", sec / ((double)60 * 60 * 24 * 30 * 12));
691: } else {
692: snprintf(buff, sizeof(buff), "解読に1000年以上かかる．");
693: }
694:
695: return (string)buff;
696: }
使用されている文字種の数を変数 num に、パスワード長を変数 len に格納し、num の len 乗がが総当たりパターン数となる。これに1パターンあたりの解読時間 DECODE_TIME を乗ずることで解読時間（秒）を求める。NVIDIA製GPU「RTX 4090」1基で、英小文字8文字からなるパスワードを5分で解読できるという記事（NVIDIAの高性能グラボは複雑なパスワードも短時間で突破可能
\[ \displaystyle DECODE\_TIME = \frac{5 \times 60}{(26 \times 2) ^ 8} \]
と算出した。
この関数は、結果を読みやすいように日本語文字列に変換して戻す。
解説：パスワードの強度を求める
698: /**
699: * 指定したパスワードの強度を求める．
700: * 強度は1〜5の整数で，数字が大きいほど強度が強い．
701: * @param string psw パスワード
702: * @param size_t min パスワードの最小長；省略時はPASSWORD_MINIMUM_LENGTH
703: * @param size_t max パスワードの最大長；省略時はPASSWORD_MAXIMUM_LENGTH
704: * @return int 強度
705: * 1：数字のみ
706: * 2：英数n文字以下
707: * 3：ブラックリスト辞書に存在する
708: * 4：1〜3をクリアし，記号が含まれていない
709: * 5：1〜3をクリアし，記号が含まれている
710: * 6：1〜5をクリアし，連続した文字がない
711: */
712: int getPasswordStrength(string psw, size_t min=PASSWORD_MINIMUM_LENGTH, size_t max=PASSWORD_MAXIMUM_LENGTH) {
713: //空白を除く
714: string str = regex_replace(psw, regex("[ \\t]+"), "");
715:
716: //パスワードstrの強度を算出する．
717: int ret = 0;
718: if ((psw.length() < min) || (psw.length() > max)) {
719: ret = 0;
720: } else if (isNumbersOnly(str)) {
721: ret = 1;
722: } else if (isAlphanumeric(str)) {
723: ret = 2;
724: } else if (inDictionary(str)) {
725: ret = 3;
726: } else if (isContainNoSymbol(str)) {
727: ret = 4;
728: } else if (isSeqCharacters(str)) {
729: ret = 5;
730: } else {
731: ret = 6;
732: }
733: return ret;
734: }
解説：辞書ファイル名を求める
288: /**
289: * 辞書ファイル名を求める．
290: * @param なし
291: * @return string 辞書ファイル名
292: */
293: const char *getDictionaryName(void) {
294: static char buff[SIZE_BUFF + 1];
295: strncpy(buff, (getMyPath(APPNAME) + FILENAME_DIC).c_str(), SIZE_BUFF);
296: return (const char *)buff;
297: }
まず、ユーザー関数 getDictionaryName は、ブラックリスト辞書ファイルへのフルパスを求める。ユーザーのAppDataの下にある。
解説：辞書ファイルを空にする
313: /**
314: * 辞書ファイルを空にする．
315: * @param なし
316: * @return bool TRUE：成功／FALSE：失敗
317: */
318: bool emptyDictionary() {
319: const char *outfname = getDictionaryName();
320: FILE *outfp;
321: outfp = fopen(outfname, "wb");
322: fclose(outfp);
323:
324: return TRUE;
325: }
解説：辞書ファイルを指定したメモリに読み込む
327: /**
328: * 辞書ファイルを指定したメモリに読み込む．
329: * @param unsigned char *dic 読み込むメモリ
330: * @return size_t 読み込んだ見出語の数
331: */
332: size_t readDictionary(unsigned char *dic) {
333: size_t cnt;
334: const char *infname = getDictionaryName();
335: FILE *infp;
336: infp = fopen(infname, "rb");
337: if (infp == NULL) {
338: ErrorMessage = "辞書ファイルが見つかりません";
339: return 0;
340: }
341:
342: //辞書カウンタを初期化してメモリに読み込む．
343: DictionaryCounter = 0;
344: for (cnt = 0; cnt < MAX_WORDS; cnt++) {
345: if (feof(infp)) break;
346: fread(dic + cnt * sizeof(Digest), sizeof(Digest), 1, infp);
347: DictionaryCounter++;
348: }
349: fclose(infp);
350:
351: return cnt;
352: }
解説：指定したハッシュ値が指定したメモリになければ追加する
372: /**
373: * 指定したハッシュ値が指定したメモリになければ追加する．
374: * 直近に登録した50万件に重複がなければ追加する．
375: * @param unsigned char *dic ハッシュ値格納メモリ
376: * @param Digest *md5 ハッシュ値
377: * @return bool TRUE：追加成功／FALSE：失敗
378: */
379: bool addDictionary(unsigned char *dic, Digest *md5) {
380: static Digest zero;
381: memset((void *)&zero, 0, sizeof(Digest));
382: size_t i;
383: static unsigned char *pointer;
384: static size_t ll = sizeof(Digest);
385: size_t cnt;
386:
387: //BACK_WORDS語だけ遡って重複チェックする．
388: if (DictionaryCounter > BACK_WORDS) {
389: cnt = DictionaryCounter - BACK_WORDS;
390: pointer = dic + cnt * ll;
391: //それ以外
392: } else {
393: cnt = 0;
394: pointer = dic;
395: }
396:
397: //指定したハッシュ値が指定したメモリになければ追加する．
398: for (i = cnt; i < MAX_WORDS; i++) {
399: if (memcmp(pointer, (void *)&zero, ll) == 0) {
400: break;
401: } else if (memcmp(pointer, (void *)md5, ll) == 0) {
402: return FALSE;
403: }
404: pointer += ll;
405: }
406:
407: //登録可能かどうかを検査する．
408: if (i >= MAX_WORDS) {
409: ErrorMessage = "辞書に登録できない";
410: return FALSE;
411: } else {
412: memcpy(dic + i * sizeof(Digest), (void *)md5, sizeof(Digest));
413: DictionaryCounter++;
414: return TRUE;
415: }
416: }
このとき、BACK_WORDS語だけ遡って重複チェックし、同じハッシュ値を見つけたら追加しないようにした。本当は銭湯に戻って重複チェックをしたかったのだが、Wikipedia見出しのように1千万語超になると重複チェックがボトルネックとなり、ブラックリスト辞書の追加に1日以上かかることから、このような処理にした。
解説：指定したメモリの内容を辞書ファイルに書き込む
354: /**
355: * 指定したメモリの内容を辞書ファイルに書き込む．
356: * @param unsigned char *dic 書き込むメモリ
357: * @param size_t cnt 見出し語の数
358: * @return bool TRUE：書き込み成功／FALSE：失敗
359: */
360: bool writeDictionary(unsigned char *dic, size_t cnt) {
361: const char *outfname = getDictionaryName();
362: FILE *outfp;
363: outfp = fopen(outfname, "wb");
364: for (size_t i = 0; i < cnt; i++) {
365: fwrite(dic + i * sizeof(Digest), sizeof(Digest), 1, outfp);
366: }
367: fclose(outfp);
368:
369: return TRUE;
370: }
解説：ブラックリスト・ファイルを読み込んで辞書ファイルに追加
418: /**
419: * ブラックリスト・ファイルを読み込んで，辞書ファイルに追加する．
420: * @param const char* infname パスワード・ファイル名
421: * @param unsigned column 読み込むカラム番号
422: * @return size_t 読み込んだ見出語の数
423: */
424: size_t readKeywords2Dictionary(const char* infname, unsigned column) {
425: //カーソルを砂時計に
426: HCURSOR cur = SetCursor(LoadCursor(NULL, IDC_WAIT));
427:
428: //辞書読み込み用のメモリを確保する。
429: unsigned char *dic;
430: dic = (unsigned char *)malloc((MAX_WORDS + 1) * sizeof(Digest));
431: memset(dic, 0, (MAX_WORDS + 1) * sizeof(Digest));
432:
433: //辞書ファイルをメモリに読み込む．
434: if (readDictionary(dic) == FALSE) {
435: return FALSE;
436: }
437:
438: //ブラックリスト・ファイルを読み込みオープンする．
439: static char s1[SIZE_BUFF + 1];
440: static char s2[SIZE_BUFF + 1];
441: FILE *infp;
442: infp = fopen(infname, "rb");
443: if (infp == NULL) {
444: ErrorMessage = (string)infname + " の読み込みに失敗しました";
445: fclose(infp);
446: return FALSE;
447: }
448:
449: //パスワードを1つずつ読み込み，ハッシュ値に変換して辞書ファイルへ追加する．
450: size_t cnt = 0;
451: size_t cnt2 = 0;
452: size_t len = 0;
453: while (cnt2 < MAX_WORDS) {
454: if (feof(infp)) break;
455: if (fgets(s1, SIZE_BUFF, infp) == NULL) break;
456: len = strlen(s1);
457: int k = 0;
458: unsigned col = 1; //カラム番号
459: for (size_t j = 0; j < len; j++) {
460: //カラム区切り文字を見つけたら，カラム番号を1つ増やす．
461: //読み込むカラム番号を超えたら読み込みを打ち切る．
462: if ((s1[j] == '\t') || (s1[j] == ' ') || (s1[j] == ',')) {
463: col++;
464: if (col > column) {
465: break;
466: }
467: k = 0;
468: //英数記号を取り込む．
469: } else if (col == column) {
470: if ((s1[j] >= '!') && (s1[j] <= '~')) {
471: //小文字に統一する．
472: s2[k] = tolower(s1[j]);
473: k++;
474: }
475: }
476: }
477: s2[k] = '\0';
478:
479: //最小長より長ければ辞書に登録する．
480: static Digest dd;
481: if (k >= PASSWORD_MINIMUM_LENGTH) {
482: //MD5ハッシュ値をddに代入する．
483: MD5((const unsigned char *)s2, k, (unsigned char *)&dd);
484:
485: // cout << s2 << endl;
486: // printDictionary((Digest *)dd);
487: // cout << endl;
488:
489: //読み込みカウンタ
490: if (cnt % 10000 == 0) {
491: cout << cnt << "=>" << cnt2 << '\r';
492: }
493: if (addDictionary(dic, &dd) == TRUE) {
494: cnt2++;
495: }
496: cnt++;
497: }
498: }
499: fclose(infp);
500:
501: //辞書ファイルへ書き込む．
502: writeDictionary(dic, DictionaryCounter);
503: cout << "\nDictionaryCounter = " << DictionaryCounter << endl;
504: //メモリを解放する．
505: free(dic);
506:
507: //カーソルを元に戻す
508: SetCursor(cur);
509:
510: return cnt2;
511: }
ブラックリスト・ファイルはテキストファイルで、1行に1パスワードが記載されているものとする。タブ、空白、カンマでカラムが区切られていてもよく、その場合は、columnにパスワードがあるカラム番号（左端の先頭が1）を指定してやる。
解説：辞書ファイルに登録されているパスワード数
513: /**
514: * 辞書ファイルに登録されているパスワード数を求める．
515: * パスワード数は"1234","約10万"のような文字列で返す．
516: * @param なし
517: * @return string パスワード数
518: */
519: string countDictionary(void) {
520: const char *infname = getDictionaryName();
521: double fsize = filesystem::file_size((string)infname) / sizeof(Digest);
522: char buff[SIZE_BUFF + 1];
523:
524: if (fsize < 10000) {
525: snprintf(buff, SIZE_BUFF, " (登録語数：%.0f)", fsize);
526: } else if (fsize < 100000000) {
527: snprintf(buff, SIZE_BUFF, " (登録語数：約%.0f万)", fsize / 10000);
528: } else if (fsize < 1000000000000) {
529: snprintf(buff, SIZE_BUFF, " (登録語数：約%.0f億)", fsize / 100000000);
530: } else {
531: snprintf(buff, SIZE_BUFF, " (登録語数：1兆以上)");
532: }
533:
534: return buff;
535: }
ブラックリスト辞書は固定長バイナリファイルなので、ハッシュ値の長さ DIGEST_LENGTH で除算すれば、登録語数を得られる。
読みやすいように、語数に応じて日本語に変換した文字列を戻す。
同梱のブラックリスト辞書について
- Wikipedia英語版 見出し語
- zxcvbn：Dropbox，2015年11月
- 使ってはいけないパスワードトップ10万：英NCSC，2019年4月
- 10-million-password-list-top-1000000.txt：Daniel Miessler，2020年7月
参考サイト
- PHPでパスワードの強度を調べる：ぱふぅ家のホームページ
- PHPでパスワードの強度を調べる（その2）：ぱふぅ家のホームページ
- WiX によるWindowsインストーラー作成：ぱふぅ家のホームページ
- C++ 開発環境の準備：ぱふぅ家のホームページ
- NIST Special Publication 800-63B：NIST
「PHPでパスワードの強度を調べる（その2）」で作ったPHPプログラムを移植したものである。
（2024年8月31日）辞書ファイルを強化，使用ライブラリ更新
（2024年5月4日）DECODE_TIMEの値を改訂
（2024年4月20日）使用ライブラリ更新
（2023年11月23日）辞書ファイルを強化，使用ライブラリ更新