RFC4634 日本語訳

4634 US Secure Hash Algorithms (SHA and HMAC-SHA). D. Eastlake 3rd, T.Hansen. July 2006. (Format: TXT=197147 bytes) (Updates RFC3174) (Status: INFORMATIONAL)
プログラムでの自動翻訳です。
RFC一覧
英語原文

Network Working Group                                    D. Eastlake 3rd
Request for Comments: 4634                                 Motorola Labs
Updates: 3174                                                  T. Hansen
Category: Informational                                        AT&T Labs
                                                               July 2006

コメントを求めるワーキンググループのD.イーストレーク第3要求をネットワークでつないでください: 4634のモトローラ研究室アップデート: 3174年のT.ハンセンカテゴリ: 情報のAT&T研究室2006年7月

              US Secure Hash Algorithms (SHA and HMAC-SHA)

米国の安全な細切れ肉料理アルゴリズム(SHAとHMAC-SHA)

Status of This Memo

このメモの状態

   This memo provides information for the Internet community.  It does
   not specify an Internet standard of any kind.  Distribution of this
   memo is unlimited.

このメモはインターネットコミュニティのための情報を提供します。 それはどんな種類のインターネット標準も指定しません。 このメモの分配は無制限です。

Copyright Notice

版権情報

   Copyright (C) The Internet Society (2006).

Copyright(C)インターネット協会(2006)。

Abstract

要約

   The United States of America has adopted a suite of Secure Hash
   Algorithms (SHAs), including four beyond SHA-1, as part of a Federal
   Information Processing Standard (FIPS), specifically SHA-224 (RFC
   3874), SHA-256, SHA-384, and SHA-512.  The purpose of this document
   is to make source code performing these hash functions conveniently
   available to the Internet community.  The sample code supports input
   strings of arbitrary bit length.  SHA-1's sample code from RFC 3174
   has also been updated to handle input strings of arbitrary bit
   length.  Most of the text herein was adapted by the authors from FIPS
   180-2.

アメリカ合衆国はひとそろいのSecure Hash Algorithms(SHAs)を採用しました、SHA-1を超えて4を含んでいて、連邦情報処理基準の一部(FIPS)、明確にSHA-224(RFC3874)、SHA-256、SHA-384、およびSHA-512として。 このドキュメントの目的は便利にこれらのハッシュ関数を実行するソースコードをインターネットコミュニティに利用可能にすることです。 サンプルコードは任意の噛み付いている長さの入力ストリングを支えます。 また、任意の噛み付いている長さの入力ストリングを扱うためにRFC3174からのSHA-1のサンプルコードをアップデートしました。 テキストの大部分は作者によってFIPS180-2からここに翻案されました。

   Code to perform SHA-based HMACs, with arbitrary bit length text, is
   also included.

また、任意の噛み付いている長さのテキストで、SHAベースのHMACsを実行するコードは含まれています。

Eastlake 3rd & Hansen        Informational                      [Page 1]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[1ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

Table of Contents

目次

   1. Overview of Contents ............................................3
      1.1. License ....................................................4
   2. Notation for Bit Strings and Integers ...........................4
   3. Operations on Words .............................................5
   4. Message Padding and Parsing .....................................6
      4.1. SHA-224 and SHA-256 ........................................7
      4.2. SHA-384 and SHA-512 ........................................8
   5. Functions and Constants Used ....................................9
      5.1. SHA-224 and SHA-256 ........................................9
      5.2. SHA-384 and SHA-512 .......................................10
   6. Computing the Message Digest ...................................11
      6.1. SHA-224 and SHA-256 Initialization ........................11
      6.2. SHA-224 and SHA-256 Processing ............................11
      6.3. SHA-384 and SHA-512 Initialization ........................13
      6.4. SHA-384 and SHA-512 Processing ............................14
   7. SHA-Based HMACs ................................................15
   8. C Code for SHAs ................................................15
      8.1. The .h File ...............................................18
      8.2. The SHA Code ..............................................24
           8.2.1. sha1.c .............................................24
           8.2.2. sha224-256.c .......................................33
           8.2.3. sha384-512.c .......................................45
           8.2.4. usha.c .............................................67
           8.2.5. sha-private.h ......................................72
      8.3. The HMAC Code .............................................73
      8.4. The Test Driver ...........................................78
   9. Security Considerations .......................................106
   10. Normative References .........................................106
   11. Informative References .......................................106

1. コンテンツの概観…3 1.1. 認可します。4 2. ビット列と整数のための記法…4 3. ワーズにおける操作…5 4. メッセージ詰め物と構文解析…6 4.1. SHA-224とSHA-256…7 4.2. SHA-384とSHA-512…8 5. 機能と使用される定数…9 5.1. SHA-224とSHA-256…9 5.2. SHA-384とSHA-512…10 6. メッセージダイジェストを計算します…11 6.1. SHA-224とSHA-256初期設定…11 6.2. SHA-224とSHA-256処理…11 6.3. SHA-384とSHA-512初期設定…13 6.4. SHA-384とSHA-512処理…14 7. SHAベースのHMACs…15 8. SHAsのためのCコード…15 8.1. .hファイル…18 8.2. SHAコード…24 8.2.1sha1c…24 8.2.2sha224-256c…33 8.2.3sha384-512c…45 8.2.4usha c…67 8.2.5sha-private h…72 8.3. HMACコード…73 8.4. テスト・ドライバ…78 9. セキュリティ問題…106 10. 標準の参照…106 11. 有益な参照…106

Eastlake 3rd & Hansen        Informational                      [Page 2]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[2ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

1.  Overview of Contents

1. コンテンツの概観

   NOTE: Much of the text below is taken from [FIPS180-2] and assertions
   therein of the security of the algorithms described are made by the
   US Government, the author of [FIPS180-2], and not by the authors of
   this document.

以下に注意してください。 そこに説明されたアルゴリズムのセキュリティについて[FIPS180-2]と主張から以下のテキストの多くを取ります。このドキュメントの作者ではなく、米国政府、[FIPS180-2]の作者が作ります。

   The text below specifies Secure Hash Algorithms, SHA-224 [RFC3874],
   SHA-256, SHA-384, and SHA-512, for computing a condensed
   representation of a message or a data file. (SHA-1 is specified in
   [RFC3174].)  When a message of any length < 2^64 bits (for SHA-224
   and SHA-256) or < 2^128 bits (for SHA-384 and SHA-512) is input to
   one of these algorithms, the result is an output called a message
   digest.  The message digests range in length from 224 to 512 bits,
   depending on the algorithm.  Secure hash algorithms are typically
   used with other cryptographic algorithms, such as digital signature
   algorithms and keyed hash authentication codes, or in the generation
   of random numbers [RFC4086].

以下のテキストはSecure Hash Algorithms、SHA-224[RFC3874]、SHA-256、SHA-384、およびSHA-512を指定します、メッセージかデータファイルの凝縮した表現を計算するために。 (SHA-1は[RFC3174]で指定されます。) 2^64ビット(SHA-224とSHA-256のための)か<2^128ビット(SHA-384とSHA-512のための)のどんな長さの<に関するメッセージもこれらのアルゴリズムの1つに入力されるとき、結果はメッセージダイジェストと呼ばれる出力です。 アルゴリズムによって、メッセージダイジェストは224〜512ビットの長さのねらいを定めます。 安全な細切れ肉料理アルゴリズムはデジタル署名アルゴリズムや合わせられた細切れ肉料理認証子などの他の暗号アルゴリズム、または乱数[RFC4086]の世代に通常使用されます。

   The four algorithms specified in this document are called secure
   because it is computationally infeasible to (1) find a message that
   corresponds to a given message digest, or (2) find two different
   messages that produce the same message digest.  Any change to a
   message in transit will, with very high probability, result in a
   different message digest.  This will result in a verification failure
   when the secure hash algorithm is used with a digital signature
   algorithm or a keyed-hash message authentication algorithm.

同じメッセージダイジェストを作成する2つの異なったメッセージを(1)が、与えられたメッセージダイジェスト、または(2)に対応するメッセージがわかる見つけるのが計算上実行不可能であるので、本書では指定された4つのアルゴリズムが安全であると呼ばれます。 非常に高い確率で、トランジットにおけるメッセージへのどんな変化も異なったメッセージダイジェストをもたらすでしょう。 安全な細切れ肉料理アルゴリズムがデジタル署名アルゴリズムか合わせられた細切れ肉料理通報認証アルゴリズムで使用されるとき、これは検証失敗をもたらすでしょう。

   The code provided herein supports input strings of arbitrary bit
   length.  SHA-1's sample code from [RFC3174] has also been updated to
   handle input strings of arbitrary bit length.  See Section 1.1 for
   license information for this code.

ここに提供されたコードは任意の噛み付いている長さの入力ストリングを支えます。 また、任意の噛み付いている長さの入力ストリングを扱うために[RFC3174]からのSHA-1のサンプルコードをアップデートしました。 このコードのためのライセンス情報に関してセクション1.1を見てください。

   Section 2 below defines the terminology and functions used as
   building blocks to form these algorithms.  Section 3 describes the
   fundamental operations on words from which these algorithms are
   built.  Section 4 describes how messages are padded up to an integral
   multiple of the required block size and then parsed into blocks.
   Section 5 defines the constants and the composite functions used to
   specify these algorithms.  Section 6 gives the actual specification
   for the SHA-224, SHA-256, SHA-384, and SHA-512 functions.  Section 7
   provides pointers to the specification of HMAC keyed message
   authentication codes based on the SHA algorithms.  Section 8 gives
   sample code for the SHA algorithms and Section 9 code for SHA-based
   HMACs.  The SHA-based HMACs will accept arbitrary bit length text.

以下のセクション2はこれらのアルゴリズムを形成するのにブロックとして使用される用語と機能を定義します。セクション3はこれらのアルゴリズムが組立している単語で基本的な操作について説明します。 セクション4はメッセージがどう必要なブロック・サイズの不可欠の倍数まで水増しされて、次に、分析されるかをブロックに説明します。 セクション5は定数を定義します、そして、合成関数は以前はよくこれらのアルゴリズムを指定していました。セクション6はSHA-224、SHA-256、SHA-384、およびSHA-512機能のための実際の仕様を与えます。 セクション7は、SHAベースのHMACsのために. セクション8がSHAアルゴリズムのためにサンプルコードを与えるSHAアルゴリズムに基づく合わせられたメッセージ確認コードをHMACの仕様へのポインタに提供して、9コードをセクションに提供します。 SHAベースのHMACsは任意の噛み付いている長さのテキストを受け入れるでしょう。

Eastlake 3rd & Hansen        Informational                      [Page 3]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[3ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

1.1.  License

1.1. ライセンス

   Permission is granted for all uses, commercial and non-commercial, of
   the sample code found in Section 8.  Royalty free license to use,
   copy, modify and distribute the software found in Section 8 is
   granted, provided that this document is identified in all material
   mentioning or referencing this software, and provided that
   redistributed derivative works do not contain misleading author or
   version information.

許可は、セクション8で見つけられたサンプルコードで、すべての用途のために与えられて、商業であって非営利的です。 セクション8で見つけられたソフトウェアを使用して、コピーして、変更して、分配するロイヤルティフリーなライセンスを与えます、再配付された派生している作品が紛らわしい作者かバージョン情報を含んでいなければこのドキュメントがこのソフトウェアに言及するか、または参照をつけながらすべての材料の中で特定されれば。

   The authors make no representations concerning either the
   merchantability of this software or the suitability of this software
   for any particular purpose.  It is provided "as is" without express
   or implied warranty of any kind.

作者はこのソフトウェアの市場性かどんな特定の目的のためのこのソフトウェアの適合のどちらかに関しても表現を全くしません。 どんな種類の急行も黙示的な保証なしでもそれを「そのままで」提供します。

2.  Notation for Bit Strings and Integers

2. ビット列と整数のための記法

   The following terminology related to bit strings and integers will be
   used:

ビット列と整数に関連する以下の用語は使用されるでしょう:

    a.  A hex digit is an element of the set {0, 1, ... , 9, A, ... ,
        F}.  A hex digit is the representation of a 4-bit string.
        Examples: 7 = 0111, A = 1010.

a。 十六進法ケタはセットの要素です。0、1、…、9、A、…、F。 十六進法ケタは4ビット列の表現です。 例: 7 = 0111、=1010。

    b.  A word equals a 32-bit or 64-bit string, which may be
        represented as a sequence of 8 or 16 hex digits, respectively.
        To convert a word to hex digits, each 4-bit string is converted
        to its hex equivalent as described in (a) above.  Example:

b。 単語は32ビットか64ビット列と等しいです。(それは、十六進法8ケタか16ケタの系列としてそれぞれ表されるかもしれません)。 十六進法ケタに単語を変換するために、各4ビット列が上で(a)で説明されるように十六進法同等物に変換されます。 例:

        1010 0001 0000 0011 1111 1110 0010 0011 = A103FE23.

1010 0001 0000 0011 1111 1110 0010 0011はA103FE23と等しいです。

        Throughout this document, the "big-endian" convention is used
        when expressing both 32-bit and 64-bit words, so that within
        each word the most significant bit is shown in the left-most bit
        position.

ともに32ビットの、そして、64ビットの言葉を表すとき、このドキュメント中では、「ビッグエンディアン」コンベンションは使用されています、最も重要なビットが最も左のビット位置で各単語の中で見せられるように。

    c.  An integer may be represented as a word or pair of words.

c。 整数は単語の単語か組として表されるかもしれません。

        An integer between 0 and 2^32 - 1 inclusive may be represented
        as a 32-bit word.  The least significant four bits of the
        integer are represented by the right-most hex digit of the word
        representation.  Example: the integer 291 = 2^8+2^5+2^1+2^0 =
        256+32+2+1 is represented by the hex word 00000123.

0と2の間で^32--1包括的な整数は32ビットの単語として表されるかもしれません。 整数の最も重要でない4ビットは表現という単語の最も権利十六進法ケタによって表されます。 例: the integer 291 = 2^8+2^5+2^1+2^0 = 256+32+2+1 is represented by the hex word 00000123.

        The same holds true for an integer between 0 and 2^64-1
        inclusive, which may be represented as a 64-bit word.

同じくらいは^64-1に包括的に0〜2の整数に当てはまります(64ビットの単語として表されるかもしれません)。

Eastlake 3rd & Hansen        Informational                      [Page 4]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[4ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

        If Z is an integer, 0 <= z < 2^64, then z = (2^32)x + y where 0
        <= x < 2^32 and 0 <= y < 2^32.  Since x and y can be represented
        as words X and Y, respectively, z can be represented as the pair
        of words (X,Y).

Zが整数であるなら、0<はz<2^64と等しいです、y次に、0<がx<2^32と0<と等しいz=(2^32)x+y=<2^32。 単語XとYとしてxとyを表すことができるので、それぞれ、単語(X、Y)の組としてzを表すことができます。

    d.  block = 512-bit or 1024-bit string.  A block (e.g., B) may be
        represented as a sequence of 32-bit or 64-bit words.

d. ブロックは512ビットか1024ビット列と等しいです。 ブロック(例えば、B)は32ビットの、または、64ビットの単語の続きとして表されるかもしれません。

3.  Operations on Words

3. ワーズにおける操作

   The following logical operators will be applied to words in all four
   hash operations specified herein.  SHA-224 and SHA-256 operate on
   32-bit words, while SHA-384 and SHA-512 operate on 64-bit words.

以下の論理演算子はここに指定されたすべての4つの細切れ肉料理操作における単語に適用されるでしょう。 SHA-224とSHA-256は32ビットの単語を作動させますが、SHA-384とSHA-512は64ビットの単語を作動させます。

   In the operations below, x<<n is obtained as follows: discard the
   left-most n bits of x and then pad the result with n zeroed bits on
   the right (the result will still be the same number of bits).

以下での操作では、以下の通りx<<nを入手します: xのn最も左のビットを捨ててください、そして、次に、ゼロに合わせられたnビットが右にある状態で、結果を水増ししてください(結果はまだ同じ数のビットになっているでしょう)。

    a.  Bitwise logical word operations

a。 論理語操作をBitwiseします。

        X AND Y  =  bitwise logical "and" of  X and Y.

XとY=はXとYの論理的な“and"をbitwiseします。

        X OR Y   =  bitwise logical "inclusive-or" of X and Y.

または、X OR Y=が論理的にbitwiseされる、「包括的である、-、」 XとYについて。

        X XOR Y  =  bitwise logical "exclusive-or" of X and Y.

X XOR Y=はXとYの論理的な「排他的論理和」をbitwiseします。

        NOT X    =  bitwise logical "complement" of X.

どんなX=もXの論理的な「補数」をbitwiseしません。

        Example:
                 01101100101110011101001001111011
           XOR   01100101110000010110100110110111
                 --------------------------------
             =   00001001011110001011101111001100

例: 01101100101110011101001001111011 XOR01100101110000010110100110110111-------------------------------- = 00001001011110001011101111001100

    b.  The operation X + Y is defined as follows: words X and Y
        represent w-bit integers x and y, where 0 <= x < 2^w and
        0 <= y < 2^w.  For positive integers n and m, let

b。 操作X+Yは以下の通り定義されます: 単語XとYはw-ビット整数xを表します、そして、y(0<はx<2^wと0<と等しい)はy<2^wと等しいです。 正の整数nとmさせる。

             n mod m

nモッズm

        be the remainder upon dividing n by m.  Compute

残りがnをm割るところにありますか? 計算してください。

             z  =  (x + y) mod 2^w.

zはモッズ2^wと等しいです(x+y)。

        Then 0 <= z < 2^w.  Convert z to a word, Z, and define Z = X +
        Y.

そして、0<はz<2^wと等しいです。 Z、zを単語に変換してください、そして、Z=X+Yを定義してください。

Eastlake 3rd & Hansen        Informational                      [Page 5]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[5ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

    c.  The right shift operation SHR^n(x), where x is a w-bit word and
        n is an integer with 0 <= n < w, is defined by

c。 xがw-ビット単語であり、nがn0<がある整数=<wであり、定義されるところのそばの正しいシフト操作SHR^n(x)

             SHR^n(x) = x>>n

x>SHR^n(x)=>n

    d.  The rotate right (circular right shift) operation ROTR^n(x),
        where x is a w-bit word and n is an integer with 0 <= n < w, is
        defined by

d。 操作ROTR^n(x)を真直(正しい円形のシフト)に回転させてください。xがw-ビット単語であり、そこでは、nは、n0<がある整数=<wであり、定義されます。

             ROTR^n(x) = (x>>n) OR (x<<(w-n))

ROTR^n(x)=(x>>n)OR(x<<(w-n))

    e.  The rotate left (circular left shift) operation ROTL^n(x), where
        x is a w-bit word and n is an integer with 0 <= n < w, is
        defined by

e。 左の(左の円形のシフト)操作ROTL^n(x)を回転させてください。xがw-ビット単語であり、そこでは、nは、n0<がある整数=<wであり、定義されます。

             ROTL^n(X)  =  (x<<n) OR (x>>w-n)

ROTL^n(X)はORと等しいです(x<<n)。(x>>w-n)

        Note the following equivalence relationships, where w is fixed
        in each relationship:

以下の等価性関係に注意してください:(そこでは、wが各関係で修理されています)。

             ROTL^n(x) = ROTR^(w-x)(x)

ROTL^n(x)はROTR^と等しいです(w-x)。(x)

             ROTR^n(x) = ROTL^(w-n)(x)

ROTR^n(x)はROTL^と等しいです(w-n)。(x)

4.  Message Padding and Parsing

4. メッセージ詰め物と構文解析

   The hash functions specified herein are used to compute a message
   digest for a message or data file that is provided as input.  The
   message or data file should be considered to be a bit string.  The
   length of the message is the number of bits in the message (the empty
   message has length 0).  If the number of bits in a message is a
   multiple of 8, for compactness we can represent the message in hex.
   The purpose of message padding is to make the total length of a
   padded message a multiple of 512 for SHA-224 and SHA-256 or a
   multiple of 1024 for SHA-384 and SHA-512.

ここに指定されたハッシュ関数は、入力されるように提供されるメッセージかデータファイルのためにメッセージダイジェストを計算するのに使用されます。 メッセージかデータファイルがしばらくストリングであると考えられるべきです。 メッセージの長さはメッセージのビットの数(空のメッセージには、長さ0がある)です。 メッセージのビットの数が8の倍数であるなら、コンパクト性のために、私たちは十六進法におけるメッセージを表すことができます。 メッセージ詰め物の目的はそっと歩いているメッセージの全長をSHA-224とSHA-256のための512の倍数かSHA-384とSHA-512のための1024年の倍数にすることです。

   The following specifies how this padding shall be performed.  As a
   summary, a "1" followed by a number of "0"s followed by a 64-bit or
   128-bit integer are appended to the end of the message to produce a
   padded message of length 512*n or 1024*n.  The minimum number of "0"s
   necessary to meet this criterion is used.  The appended integer is
   the length of the original message.  The padded message is then
   processed by the hash function as n 512-bit or 1024-bit blocks.

以下はこの詰め物がどう実行されるかを指定します。 概要、a、「64ビットの、または、128ビットの整数を「長さ512*nか1024*nのそっと歩いているメッセージを出すメッセージの終わりまで0"sを追加して、続いて追加します」のa番号に従って、1インチは続きました。 最小の数「この評価基準を満たすのに必要な0"sは使用されています」。 追加された整数はオリジナルのメッセージの長さです。 そして、そっと歩いているメッセージはn512ビットの、または、1024年のビットのブロックとしてハッシュ関数によって処理されます。

Eastlake 3rd & Hansen        Informational                      [Page 6]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[6ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

4.1.  SHA-224 and SHA-256

4.1. SHA-224とSHA-256

   Suppose a message has length L < 2^64.  Before it is input to the
   hash function, the message is padded on the right as follows:

メッセージには長さL<2^64があると仮定してください。 それがハッシュ関数に入力される前に、メッセージは以下の右で水増しされます:

    a.  "1" is appended.  Example: if the original message is
        "01010000", this is padded to "010100001".

a。 「1インチを追加します。」 例: オリジナルのメッセージが「01010000」であるなら、これは「010100001」に水増しされます。

    b.  K "0"s are appended where K is the smallest, non-negative
        solution to the equation

b。 K、「Kが方程式の最も小さくて、非ネガの溶液であるところに0"sを追加します」。

             L + 1 + K = 448 (mod 512)

L+1+K=448(モッズ風の512)

    c.  Then append the 64-bit block that is L in binary representation.
        After appending this block, the length of the message will be a
        multiple of 512 bits.

c。 そして、2進法表示でLである64ビットのブロックを追加してください。 このブロックを追加した後に、メッセージの長さは512ビットの倍数になるでしょう。

        Example:  Suppose the original message is the bit string

例: オリジナルのメッセージがビット列であると仮定してください。

             01100001 01100010 01100011 01100100 01100101

01100001 01100010 01100011 01100100 01100101

        After step (a), this gives

ステップ(a)後に与える、これは与えます。

             01100001 01100010 01100011 01100100 01100101 1

01100001 01100010 01100011 01100100 01100101 1

        Since L = 40, the number of bits in the above is 41 and K = 407
        "0"s are appended, making the total now 448.  This gives the
        following in hex:

L=40以来、上記のビットの数は41であり、K=407は「0"sを追加します、合計を現在の448にして」です。 これは十六進法で以下を与えます:

             61626364 65800000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000

61626364 65800000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000

        The 64-bit representation of L = 40 is hex 00000000 00000028.
        Hence the final padded message is the following hex:

L=40の64ビットの表現は十六進法00000000 00000028です。 したがって、最終的なそっと歩いているメッセージは以下の十六進法です:

             61626364 65800000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000028

61626364 65800000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000028

Eastlake 3rd & Hansen        Informational                      [Page 7]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[7ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

4.2.  SHA-384 and SHA-512

4.2. SHA-384とSHA-512

   Suppose a message has length L < 2^128.  Before it is input to the
   hash function, the message is padded on the right as follows:

メッセージには長さL<2^128があると仮定してください。 それがハッシュ関数に入力される前に、メッセージは以下の右で水増しされます:

    a.  "1" is appended.  Example: if the original message is
        "01010000", this is padded to "010100001".

a. "1" is appended. Example: if the original message is "01010000", this is padded to "010100001".

    b.  K "0"s are appended where K is the smallest, non-negative
        solution to the equation

b. K "0"s are appended where K is the smallest, non-negative solution to the equation

             L + 1 + K = 896 (mod 1024)

L + 1 + K = 896 (mod 1024)

    c.  Then append the 128-bit block that is L in binary
        representation.  After appending this block, the length of the
        message will be a multiple of 1024 bits.

c. Then append the 128-bit block that is L in binary representation. After appending this block, the length of the message will be a multiple of 1024 bits.

        Example:  Suppose the original message is the bit string

Example: Suppose the original message is the bit string

             01100001 01100010 01100011 01100100 01100101

01100001 01100010 01100011 01100100 01100101

        After step (a) this gives

After step (a) this gives

             01100001 01100010 01100011 01100100 01100101 1

01100001 01100010 01100011 01100100 01100101 1

        Since L = 40, the number of bits in the above is 41 and K = 855
        "0"s are appended, making the total now 896.  This gives the
        following in hex:

Since L = 40, the number of bits in the above is 41 and K = 855 "0"s are appended, making the total now 896. This gives the following in hex:

             61626364 65800000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000000

61626364 65800000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000

        The 128-bit representation of L = 40 is hex 00000000 00000000
        00000000 00000028.  Hence the final padded message is the
        following hex:

The 128-bit representation of L = 40 is hex 00000000 00000000 00000000 00000028. Hence the final padded message is the following hex:

             61626364 65800000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000000

61626364 65800000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000

Eastlake 3rd & Hansen        Informational                      [Page 8]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 8] RFC 4634 SHAs and HMAC-SHAs July 2006

             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000000
             00000000 00000000 00000000 00000028

00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000028

5.  Functions and Constants Used

5. Functions and Constants Used

   The following subsections give the six logical functions and the
   table of constants used in each of the hash functions.

The following subsections give the six logical functions and the table of constants used in each of the hash functions.

5.1.  SHA-224 and SHA-256

5.1. SHA-224 and SHA-256

   SHA-224 and SHA-256 use six logical functions, where each function
   operates on 32-bit words, which are represented as x, y, and z.  The
   result of each function is a new 32-bit word.

SHA-224 and SHA-256 use six logical functions, where each function operates on 32-bit words, which are represented as x, y, and z. The result of each function is a new 32-bit word.

        CH( x, y, z) = (x AND y) XOR ( (NOT x) AND z)

CH( x, y, z) = (x AND y) XOR ( (NOT x) AND z)

        MAJ( x, y, z) = (x AND y) XOR (x AND z) XOR (y AND z)

MAJ( x, y, z) = (x AND y) XOR (x AND z) XOR (y AND z)

        BSIG0(x) = ROTR^2(x) XOR ROTR^13(x) XOR ROTR^22(x)

BSIG0(x) = ROTR^2(x) XOR ROTR^13(x) XOR ROTR^22(x)

        BSIG1(x) = ROTR^6(x) XOR ROTR^11(x) XOR ROTR^25(x)

BSIG1(x) = ROTR^6(x) XOR ROTR^11(x) XOR ROTR^25(x)

        SSIG0(x) = ROTR^7(x) XOR ROTR^18(x) XOR SHR^3(x)

SSIG0(x) = ROTR^7(x) XOR ROTR^18(x) XOR SHR^3(x)

        SSIG1(x) = ROTR^17(x) XOR ROTR^19(x) XOR SHR^10(x)

SSIG1(x) = ROTR^17(x) XOR ROTR^19(x) XOR SHR^10(x)

   SHA-224 and SHA-256 use the same sequence of sixty-four constant
   32-bit words, K0, K1, ..., K63.  These words represent the first
   thirty-two bits of the fractional parts of the cube roots of the
   first sixty-four prime numbers.  In hex, these constant words are as
   follows (from left to right):

SHA-224 and SHA-256 use the same sequence of sixty-four constant 32-bit words, K0, K1, ..., K63. These words represent the first thirty-two bits of the fractional parts of the cube roots of the first sixty-four prime numbers. In hex, these constant words are as follows (from left to right):

        428a2f98 71374491 b5c0fbcf e9b5dba5
        3956c25b 59f111f1 923f82a4 ab1c5ed5
        d807aa98 12835b01 243185be 550c7dc3
        72be5d74 80deb1fe 9bdc06a7 c19bf174
        e49b69c1 efbe4786 0fc19dc6 240ca1cc
        2de92c6f 4a7484aa 5cb0a9dc 76f988da
        983e5152 a831c66d b00327c8 bf597fc7
        c6e00bf3 d5a79147 06ca6351 14292967
        27b70a85 2e1b2138 4d2c6dfc 53380d13
        650a7354 766a0abb 81c2c92e 92722c85
        a2bfe8a1 a81a664b c24b8b70 c76c51a3
        d192e819 d6990624 f40e3585 106aa070
        19a4c116 1e376c08 2748774c 34b0bcb5

428a2f98 71374491 b5c0fbcf e9b5dba5 3956c25b 59f111f1 923f82a4 ab1c5ed5 d807aa98 12835b01 243185be 550c7dc3 72be5d74 80deb1fe 9bdc06a7 c19bf174 e49b69c1 efbe4786 0fc19dc6 240ca1cc 2de92c6f 4a7484aa 5cb0a9dc 76f988da 983e5152 a831c66d b00327c8 bf597fc7 c6e00bf3 d5a79147 06ca6351 14292967 27b70a85 2e1b2138 4d2c6dfc 53380d13 650a7354 766a0abb 81c2c92e 92722c85 a2bfe8a1 a81a664b c24b8b70 c76c51a3 d192e819 d6990624 f40e3585 106aa070 19a4c116 1e376c08 2748774c 34b0bcb5

Eastlake 3rd & Hansen        Informational                      [Page 9]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 9] RFC 4634 SHAs and HMAC-SHAs July 2006

        391c0cb3 4ed8aa4a 5b9cca4f 682e6ff3
        748f82ee 78a5636f 84c87814 8cc70208
        90befffa a4506ceb bef9a3f7 c67178f2

391c0cb3 4ed8aa4a 5b9cca4f 682e6ff3 748f82ee 78a5636f 84c87814 8cc70208 90befffa a4506ceb bef9a3f7 c67178f2

5.2.  SHA-384 and SHA-512

5.2. SHA-384 and SHA-512

   SHA-384 and SHA-512 each use six logical functions, where each
   function operates on 64-bit words, which are represented as x, y, and
   z.  The result of each function is a new 64-bit word.

SHA-384 and SHA-512 each use six logical functions, where each function operates on 64-bit words, which are represented as x, y, and z. The result of each function is a new 64-bit word.

        CH( x, y, z) = (x AND y) XOR ( (NOT x) AND z)

CH( x, y, z) = (x AND y) XOR ( (NOT x) AND z)

        MAJ( x, y, z) = (x AND y) XOR (x AND z) XOR (y AND z)

MAJ( x, y, z) = (x AND y) XOR (x AND z) XOR (y AND z)

        BSIG0(x) = ROTR^28(x) XOR ROTR^34(x) XOR ROTR^39(x)

BSIG0(x) = ROTR^28(x) XOR ROTR^34(x) XOR ROTR^39(x)

        BSIG1(x) = ROTR^14(x) XOR ROTR^18(x) XOR ROTR^41(x)

BSIG1(x) = ROTR^14(x) XOR ROTR^18(x) XOR ROTR^41(x)

        SSIG0(x) = ROTR^1(x) XOR ROTR^8(x) XOR SHR^7(x)

SSIG0(x) = ROTR^1(x) XOR ROTR^8(x) XOR SHR^7(x)

        SSIG1(x) = ROTR^19(x) XOR ROTR^61(x) XOR SHR^6(x)

SSIG1(x) = ROTR^19(x) XOR ROTR^61(x) XOR SHR^6(x)

   SHA-384 and SHA-512 use the same sequence of eighty constant 64-bit
   words, K0, K1, ... K79.  These words represent the first sixty-four
   bits of the fractional parts of the cube roots of the first eighty
   prime numbers.  In hex, these constant words are as follows (from
   left to right):

SHA-384 and SHA-512 use the same sequence of eighty constant 64-bit words, K0, K1, ... K79. These words represent the first sixty-four bits of the fractional parts of the cube roots of the first eighty prime numbers. In hex, these constant words are as follows (from left to right):

   428a2f98d728ae22 7137449123ef65cd b5c0fbcfec4d3b2f e9b5dba58189dbbc
   3956c25bf348b538 59f111f1b605d019 923f82a4af194f9b ab1c5ed5da6d8118
   d807aa98a3030242 12835b0145706fbe 243185be4ee4b28c 550c7dc3d5ffb4e2
   72be5d74f27b896f 80deb1fe3b1696b1 9bdc06a725c71235 c19bf174cf692694
   e49b69c19ef14ad2 efbe4786384f25e3 0fc19dc68b8cd5b5 240ca1cc77ac9c65
   2de92c6f592b0275 4a7484aa6ea6e483 5cb0a9dcbd41fbd4 76f988da831153b5
   983e5152ee66dfab a831c66d2db43210 b00327c898fb213f bf597fc7beef0ee4
   c6e00bf33da88fc2 d5a79147930aa725 06ca6351e003826f 142929670a0e6e70
   27b70a8546d22ffc 2e1b21385c26c926 4d2c6dfc5ac42aed 53380d139d95b3df
   650a73548baf63de 766a0abb3c77b2a8 81c2c92e47edaee6 92722c851482353b
   a2bfe8a14cf10364 a81a664bbc423001 c24b8b70d0f89791 c76c51a30654be30
   d192e819d6ef5218 d69906245565a910 f40e35855771202a 106aa07032bbd1b8
   19a4c116b8d2d0c8 1e376c085141ab53 2748774cdf8eeb99 34b0bcb5e19b48a8
   391c0cb3c5c95a63 4ed8aa4ae3418acb 5b9cca4f7763e373 682e6ff3d6b2b8a3
   748f82ee5defb2fc 78a5636f43172f60 84c87814a1f0ab72 8cc702081a6439ec
   90befffa23631e28 a4506cebde82bde9 bef9a3f7b2c67915 c67178f2e372532b
   ca273eceea26619c d186b8c721c0c207 eada7dd6cde0eb1e f57d4f7fee6ed178
   06f067aa72176fba 0a637dc5a2c898a6 113f9804bef90dae 1b710b35131c471b
   28db77f523047d84 32caab7b40c72493 3c9ebe0a15c9bebc 431d67c49c100d4c
   4cc5d4becb3e42b6 597f299cfc657e2a 5fcb6fab3ad6faec 6c44198c4a475817

428a2f98d728ae22 7137449123ef65cd b5c0fbcfec4d3b2f e9b5dba58189dbbc 3956c25bf348b538 59f111f1b605d019 923f82a4af194f9b ab1c5ed5da6d8118 d807aa98a3030242 12835b0145706fbe 243185be4ee4b28c 550c7dc3d5ffb4e2 72be5d74f27b896f 80deb1fe3b1696b1 9bdc06a725c71235 c19bf174cf692694 e49b69c19ef14ad2 efbe4786384f25e3 0fc19dc68b8cd5b5 240ca1cc77ac9c65 2de92c6f592b0275 4a7484aa6ea6e483 5cb0a9dcbd41fbd4 76f988da831153b5 983e5152ee66dfab a831c66d2db43210 b00327c898fb213f bf597fc7beef0ee4 c6e00bf33da88fc2 d5a79147930aa725 06ca6351e003826f 142929670a0e6e70 27b70a8546d22ffc 2e1b21385c26c926 4d2c6dfc5ac42aed 53380d139d95b3df 650a73548baf63de 766a0abb3c77b2a8 81c2c92e47edaee6 92722c851482353b a2bfe8a14cf10364 a81a664bbc423001 c24b8b70d0f89791 c76c51a30654be30 d192e819d6ef5218 d69906245565a910 f40e35855771202a 106aa07032bbd1b8 19a4c116b8d2d0c8 1e376c085141ab53 2748774cdf8eeb99 34b0bcb5e19b48a8 391c0cb3c5c95a63 4ed8aa4ae3418acb 5b9cca4f7763e373 682e6ff3d6b2b8a3 748f82ee5defb2fc 78a5636f43172f60 84c87814a1f0ab72 8cc702081a6439ec 90befffa23631e28 a4506cebde82bde9 bef9a3f7b2c67915 c67178f2e372532b ca273eceea26619c d186b8c721c0c207 eada7dd6cde0eb1e f57d4f7fee6ed178 06f067aa72176fba 0a637dc5a2c898a6 113f9804bef90dae 1b710b35131c471b 28db77f523047d84 32caab7b40c72493 3c9ebe0a15c9bebc 431d67c49c100d4c 4cc5d4becb3e42b6 597f299cfc657e2a 5fcb6fab3ad6faec 6c44198c4a475817

Eastlake 3rd & Hansen        Informational                     [Page 10]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 10] RFC 4634 SHAs and HMAC-SHAs July 2006

6.  Computing the Message Digest

6. Computing the Message Digest

   The output of each of the secure hash functions, after being applied
   to a message of N blocks, is the hash quantity H(N).  For SHA-224 and
   SHA-256, H(i) can be considered to be eight 32-bit words, H(i)0,
   H(i)1, ... H(i)7.  For SHA-384 and SHA-512, it can be considered to
   be eight 64-bit words, H(i)0, H(i)1, ..., H(i)7.

The output of each of the secure hash functions, after being applied to a message of N blocks, is the hash quantity H(N). For SHA-224 and SHA-256, H(i) can be considered to be eight 32-bit words, H(i)0, H(i)1, ... H(i)7. For SHA-384 and SHA-512, it can be considered to be eight 64-bit words, H(i)0, H(i)1, ..., H(i)7.

   As described below, the hash words are initialized, modified as each
   message block is processed, and finally concatenated after processing
   the last block to yield the output.  For SHA-256 and SHA-512, all of
   the H(N) variables are concatenated while the SHA-224 and SHA-384
   hashes are produced by omitting some from the final concatenation.

As described below, the hash words are initialized, modified as each message block is processed, and finally concatenated after processing the last block to yield the output. For SHA-256 and SHA-512, all of the H(N) variables are concatenated while the SHA-224 and SHA-384 hashes are produced by omitting some from the final concatenation.

6.1.  SHA-224 and SHA-256 Initialization

6.1. SHA-224 and SHA-256 Initialization

   For SHA-224, the initial hash value, H(0), consists of the following
   32-bit words in hex:

For SHA-224, the initial hash value, H(0), consists of the following 32-bit words in hex:

        H(0)0 = c1059ed8
        H(0)1 = 367cd507
        H(0)2 = 3070dd17
        H(0)3 = f70e5939
        H(0)4 = ffc00b31
        H(0)5 = 68581511
        H(0)6 = 64f98fa7
        H(0)7 = befa4fa4

H(0)0 = c1059ed8 H(0)1 = 367cd507 H(0)2 = 3070dd17 H(0)3 = f70e5939 H(0)4 = ffc00b31 H(0)5 = 68581511 H(0)6 = 64f98fa7 H(0)7 = befa4fa4

   For SHA-256, the initial hash value, H(0), consists of the following
   eight 32-bit words, in hex.  These words were obtained by taking the
   first thirty-two bits of the fractional parts of the square roots of
   the first eight prime numbers.

For SHA-256, the initial hash value, H(0), consists of the following eight 32-bit words, in hex. These words were obtained by taking the first thirty-two bits of the fractional parts of the square roots of the first eight prime numbers.

        H(0)0 = 6a09e667
        H(0)1 = bb67ae85
        H(0)2 = 3c6ef372
        H(0)3 = a54ff53a
        H(0)4 = 510e527f
        H(0)5 = 9b05688c
        H(0)6 = 1f83d9ab
        H(0)7 = 5be0cd19

H(0)0 = 6a09e667 H(0)1 = bb67ae85 H(0)2 = 3c6ef372 H(0)3 = a54ff53a H(0)4 = 510e527f H(0)5 = 9b05688c H(0)6 = 1f83d9ab H(0)7 = 5be0cd19

6.2.  SHA-224 and SHA-256 Processing

6.2. SHA-224 and SHA-256 Processing

   SHA-224 and SHA-256 perform identical processing on messages blocks
   and differ only in how H(0) is initialized and how they produce their
   final output.  They may be used to hash a message, M, having a length
   of L bits, where 0 <= L < 2^64.  The algorithm uses (1) a message

SHA-224 and SHA-256 perform identical processing on messages blocks and differ only in how H(0) is initialized and how they produce their final output. They may be used to hash a message, M, having a length of L bits, where 0 <= L < 2^64. The algorithm uses (1) a message

Eastlake 3rd & Hansen        Informational                     [Page 11]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 11] RFC 4634 SHAs and HMAC-SHAs July 2006

   schedule of sixty-four 32-bit words, (2) eight working variables of
   32 bits each, and (3) a hash value of eight 32-bit words.

schedule of sixty-four 32-bit words, (2) eight working variables of 32 bits each, and (3) a hash value of eight 32-bit words.

   The words of the message schedule are labeled W0, W1, ..., W63.  The
   eight working variables are labeled a, b, c, d, e, f, g, and h.  The
   words of the hash value are labeled H(i)0, H(i)1, ..., H(i)7, which
   will hold the initial hash value, H(0), replaced by each successive
   intermediate hash value (after each message block is processed),
   H(i), and ending with the final hash value, H(N), after all N blocks
   are processed.  They also use two temporary words, T1 and T2.

The words of the message schedule are labeled W0, W1, ..., W63. The eight working variables are labeled a, b, c, d, e, f, g, and h. The words of the hash value are labeled H(i)0, H(i)1, ..., H(i)7, which will hold the initial hash value, H(0), replaced by each successive intermediate hash value (after each message block is processed), H(i), and ending with the final hash value, H(N), after all N blocks are processed. They also use two temporary words, T1 and T2.

   The input message is padded as described in Section 4.1 above then
   parsed into 512-bit blocks, which are considered to be composed of 16
   32-bit words M(i)0, M(i)1, ..., M(i)15.  The following computations
   are then performed for each of the N message blocks.  All addition is
   performed modulo 2^32.

The input message is padded as described in Section 4.1 above then parsed into 512-bit blocks, which are considered to be composed of 16 32-bit words M(i)0, M(i)1, ..., M(i)15. The following computations are then performed for each of the N message blocks. All addition is performed modulo 2^32.

   For i = 1 to N

For i = 1 to N

      1. Prepare the message schedule W:
         For t = 0 to 15
            Wt = M(i)t
         For t = 16 to 63
            Wt = SSIG1(W(t-2)) + W(t-7) + SSIG0(t-15) + W(t-16)

1. Prepare the message schedule W: For t = 0 to 15 Wt = M(i)t For t = 16 to 63 Wt = SSIG1(W(t-2)) + W(t-7) + SSIG0(t-15) + W(t-16)

      2. Initialize the working variables:
         a = H(i-1)0
         b = H(i-1)1
         c = H(i-1)2
         d = H(i-1)3
         e = H(i-1)4
         f = H(i-1)5
         g = H(i-1)6
         h = H(i-1)7

2. Initialize the working variables: a = H(i-1)0 b = H(i-1)1 c = H(i-1)2 d = H(i-1)3 e = H(i-1)4 f = H(i-1)5 g = H(i-1)6 h = H(i-1)7

      3. Perform the main hash computation:
         For t = 0 to 63
            T1 = h + BSIG1(e) + CH(e,f,g) + Kt + Wt
            T2 = BSIG0(a) + MAJ(a,b,c)
            h = g
            g = f
            f = e
            e = d + T1
            d = c
            c = b
            b = a
            a = T1 + T2

3. Perform the main hash computation: For t = 0 to 63 T1 = h + BSIG1(e) + CH(e,f,g) + Kt + Wt T2 = BSIG0(a) + MAJ(a,b,c) h = g g = f f = e e = d + T1 d = c c = b b = a a = T1 + T2

Eastlake 3rd & Hansen        Informational                     [Page 12]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 12] RFC 4634 SHAs and HMAC-SHAs July 2006

      4. Compute the intermediate hash value H(i):
         H(i)0 = a + H(i-1)0
         H(i)1 = b + H(i-1)1
         H(i)2 = c + H(i-1)2
         H(i)3 = d + H(i-1)3
         H(i)4 = e + H(i-1)4
         H(i)5 = f + H(i-1)5
         H(i)6 = g + H(i-1)6
         H(i)7 = h + H(i-1)7

4. Compute the intermediate hash value H(i): H(i)0 = a + H(i-1)0 H(i)1 = b + H(i-1)1 H(i)2 = c + H(i-1)2 H(i)3 = d + H(i-1)3 H(i)4 = e + H(i-1)4 H(i)5 = f + H(i-1)5 H(i)6 = g + H(i-1)6 H(i)7 = h + H(i-1)7

   After the above computations have been sequentially performed for all
   of the blocks in the message, the final output is calculated.  For
   SHA-256, this is the concatenation of all of H(N)0, H(N)1, through
   H(N)7.  For SHA-224, this is the concatenation of H(N)0, H(N)1,
   through H(N)6.

After the above computations have been sequentially performed for all of the blocks in the message, the final output is calculated. For SHA-256, this is the concatenation of all of H(N)0, H(N)1, through H(N)7. For SHA-224, this is the concatenation of H(N)0, H(N)1, through H(N)6.

6.3.  SHA-384 and SHA-512 Initialization

6.3. SHA-384 and SHA-512 Initialization

   For SHA-384, the initial hash value, H(0), consists of the following
   eight 64-bit words, in hex.  These words were obtained by taking the
   first sixty-four bits of the fractional parts of the square roots of
   the ninth through sixteenth prime numbers.

For SHA-384, the initial hash value, H(0), consists of the following eight 64-bit words, in hex. These words were obtained by taking the first sixty-four bits of the fractional parts of the square roots of the ninth through sixteenth prime numbers.

        H(0)0 = cbbb9d5dc1059ed8
        H(0)1 = 629a292a367cd507
        H(0)2 = 9159015a3070dd17
        H(0)3 = 152fecd8f70e5939
        H(0)4 = 67332667ffc00b31
        H(0)5 = 8eb44a8768581511
        H(0)6 = db0c2e0d64f98fa7
        H(0)7 = 47b5481dbefa4fa4

H(0)0 = cbbb9d5dc1059ed8 H(0)1 = 629a292a367cd507 H(0)2 = 9159015a3070dd17 H(0)3 = 152fecd8f70e5939 H(0)4 = 67332667ffc00b31 H(0)5 = 8eb44a8768581511 H(0)6 = db0c2e0d64f98fa7 H(0)7 = 47b5481dbefa4fa4

   For SHA-512, the initial hash value, H(0), consists of the following
   eight 64-bit words, in hex.  These words were obtained by taking the
   first sixty-four bits of the fractional parts of the square roots of
   the first eight prime numbers.

For SHA-512, the initial hash value, H(0), consists of the following eight 64-bit words, in hex. These words were obtained by taking the first sixty-four bits of the fractional parts of the square roots of the first eight prime numbers.

        H(0)0 = 6a09e667f3bcc908
        H(0)1 = bb67ae8584caa73b
        H(0)2 = 3c6ef372fe94f82b
        H(0)3 = a54ff53a5f1d36f1
        H(0)4 = 510e527fade682d1
        H(0)5 = 9b05688c2b3e6c1f
        H(0)6 = 1f83d9abfb41bd6b
        H(0)7 = 5be0cd19137e2179

H(0)0 = 6a09e667f3bcc908 H(0)1 = bb67ae8584caa73b H(0)2 = 3c6ef372fe94f82b H(0)3 = a54ff53a5f1d36f1 H(0)4 = 510e527fade682d1 H(0)5 = 9b05688c2b3e6c1f H(0)6 = 1f83d9abfb41bd6b H(0)7 = 5be0cd19137e2179

Eastlake 3rd & Hansen        Informational                     [Page 13]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 13] RFC 4634 SHAs and HMAC-SHAs July 2006

6.4.  SHA-384 and SHA-512 Processing

6.4. SHA-384 and SHA-512 Processing

   SHA-384 and SHA-512 perform identical processing on message blocks
   and differ only in how H(0) is initialized and how they produce their
   final output.  They may be used to hash a message, M, having a length
   of L bits, where 0 <= L < 2^128.  The algorithm uses (1) a message
   schedule of eighty 64-bit words, (2) eight working variables of 64
   bits each, and (3) a hash value of eight 64-bit words.

SHA-384 and SHA-512 perform identical processing on message blocks and differ only in how H(0) is initialized and how they produce their final output. They may be used to hash a message, M, having a length of L bits, where 0 <= L < 2^128. The algorithm uses (1) a message schedule of eighty 64-bit words, (2) eight working variables of 64 bits each, and (3) a hash value of eight 64-bit words.

   The words of the message schedule are labeled W0, W1, ..., W79.  The
   eight working variables are labeled a, b, c, d, e, f, g, and h.  The
   words of the hash value are labeled H(i)0, H(i)1, ..., H(i)7, which
   will hold the initial hash value, H(0), replaced by each successive
   intermediate hash value (after each message block is processed),
   H(i), and ending with the final hash value, H(N) after all N blocks
   are processed.

The words of the message schedule are labeled W0, W1, ..., W79. The eight working variables are labeled a, b, c, d, e, f, g, and h. The words of the hash value are labeled H(i)0, H(i)1, ..., H(i)7, which will hold the initial hash value, H(0), replaced by each successive intermediate hash value (after each message block is processed), H(i), and ending with the final hash value, H(N) after all N blocks are processed.

   The input message is padded as described in Section 4.2 above, then
   parsed into 1024-bit blocks, which are considered to be composed of
   16 64-bit words M(i)0, M(i)1, ..., M(i)15.  The following
   computations are then performed for each of the N message blocks.
   All addition is performed modulo 2^64.

The input message is padded as described in Section 4.2 above, then parsed into 1024-bit blocks, which are considered to be composed of 16 64-bit words M(i)0, M(i)1, ..., M(i)15. The following computations are then performed for each of the N message blocks. All addition is performed modulo 2^64.

   For i = 1 to N

For i = 1 to N

      1. Prepare the message schedule W:
         For t = 0 to 15
            Wt = M(i)t
         For t = 16 to 79
            Wt = SSIG1(W(t-2)) + W(t-7) + SSIG0(t-15) + W(t-16)

1. Prepare the message schedule W: For t = 0 to 15 Wt = M(i)t For t = 16 to 79 Wt = SSIG1(W(t-2)) + W(t-7) + SSIG0(t-15) + W(t-16)

      2. Initialize the working variables:
         a = H(i-1)0
         b = H(i-1)1
         c = H(i-1)2
         d = H(i-1)3
         e = H(i-1)4
         f = H(i-1)5
         g = H(i-1)6
         h = H(i-1)7

2. Initialize the working variables: a = H(i-1)0 b = H(i-1)1 c = H(i-1)2 d = H(i-1)3 e = H(i-1)4 f = H(i-1)5 g = H(i-1)6 h = H(i-1)7

      3. Perform the main hash computation:
         For t = 0 to 79
            T1 = h + BSIG1(e) + CH(e,f,g) + Kt + Wt
            T2 = BSIG0(a) + MAJ(a,b,c)
            h = g
            g = f
            f = e

3. Perform the main hash computation: For t = 0 to 79 T1 = h + BSIG1(e) + CH(e,f,g) + Kt + Wt T2 = BSIG0(a) + MAJ(a,b,c) h = g g = f f = e

Eastlake 3rd & Hansen        Informational                     [Page 14]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 14] RFC 4634 SHAs and HMAC-SHAs July 2006

            e = d + T1
            d = c
            c = b
            b = a
            a = T1 + T2

e = d + T1 d = c c = b b = a a = T1 + T2

      4. Compute the intermediate hash value H(i):
         H(i)0 = a + H(i-1)0
         H(i)1 = b + H(i-1)1
         H(i)2 = c + H(i-1)2
         H(i)3 = d + H(i-1)3
         H(i)4 = e + H(i-1)4
         H(i)5 = f + H(i-1)5
         H(i)6 = g + H(i-1)6
         H(i)7 = h + H(i-1)7

4. Compute the intermediate hash value H(i): H(i)0 = a + H(i-1)0 H(i)1 = b + H(i-1)1 H(i)2 = c + H(i-1)2 H(i)3 = d + H(i-1)3 H(i)4 = e + H(i-1)4 H(i)5 = f + H(i-1)5 H(i)6 = g + H(i-1)6 H(i)7 = h + H(i-1)7

   After the above computations have been sequentially performed for all
   of the blocks in the message, the final output is calculated.  For
   SHA-512, this is the concatenation of all of H(N)0, H(N)1, through
   H(N)7.  For SHA-384, this is the concatenation of H(N)0, H(N)1,
   through H(N)5.

After the above computations have been sequentially performed for all of the blocks in the message, the final output is calculated. For SHA-512, this is the concatenation of all of H(N)0, H(N)1, through H(N)7. For SHA-384, this is the concatenation of H(N)0, H(N)1, through H(N)5.

7.  SHA-Based HMACs

7. SHA-Based HMACs

   HMAC is a method for computing a keyed MAC (message authentication
   code) using a hash function as described in [RFC2104].  It uses a key
   to mix in with the input text to produce the final hash.

HMAC is a method for computing a keyed MAC (message authentication code) using a hash function as described in [RFC2104]. It uses a key to mix in with the input text to produce the final hash.

   Sample code is also provided, in Section 8.3 below, to perform HMAC
   based on any of the SHA algorithms described herein.  The sample code
   found in [RFC2104] was written in terms of a specified text size.
   Since SHA is defined in terms of an arbitrary number of bits, the
   sample HMAC code has been written to allow the text input to HMAC to
   have an arbitrary number of octets and bits.  A fixed-length
   interface is also provided.

Sample code is also provided, in Section 8.3 below, to perform HMAC based on any of the SHA algorithms described herein. The sample code found in [RFC2104] was written in terms of a specified text size. Since SHA is defined in terms of an arbitrary number of bits, the sample HMAC code has been written to allow the text input to HMAC to have an arbitrary number of octets and bits. A fixed-length interface is also provided.

8.  C Code for SHAs

8. C Code for SHAs

   Below is a demonstration implementation of these secure hash
   functions in C.  Section 8.1 contains the header file sha.h, which
   declares all constants, structures, and functions used by the sha and
   hmac functions.  Section 8.2 contains the C code for sha1.c,
   sha224-256.c, sha384-512.c, and usha.c along with sha-private.h,
   which provides some declarations common to all the sha functions.
   Section 8.3 contains the C code for the hmac functions.  Section 8.4
   contains a test driver to exercise the code.

Below is a demonstration implementation of these secure hash functions in C. Section 8.1 contains the header file sha.h, which declares all constants, structures, and functions used by the sha and hmac functions. Section 8.2 contains the C code for sha1.c, sha224-256.c, sha384-512.c, and usha.c along with sha-private.h, which provides some declarations common to all the sha functions. Section 8.3 contains the C code for the hmac functions. Section 8.4 contains a test driver to exercise the code.

Eastlake 3rd & Hansen        Informational                     [Page 15]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 15] RFC 4634 SHAs and HMAC-SHAs July 2006

   For each of the digest length $$$, there is the following set of
   constants, a structure, and functions:

For each of the digest length $$$, there is the following set of constants, a structure, and functions:

   Constants:
      SHA$$$HashSize      number of octets in the hash
      SHA$$$HashSizeBits  number of bits in the hash
      SHA$$$_Message_Block_Size
                          number of octets used in the intermediate
                          message blocks
      shaSuccess = 0      constant returned by each function on success
      shaNull = 1         constant returned by each function when
                          presented with a null pointer parameter
      shaInputTooLong = 2  constant returned by each function when the
                          input data is too long
      shaStateError       constant returned by each function when
                          SHA$$$Input is called after SHA$$$FinalBits or
                          SHA$$$Result.

Constants: SHA$$$HashSize number of octets in the hash SHA$$$HashSizeBits number of bits in the hash SHA$$$_Message_Block_Size number of octets used in the intermediate message blocks shaSuccess = 0 constant returned by each function on success shaNull = 1 constant returned by each function when presented with a null pointer parameter shaInputTooLong = 2 constant returned by each function when the input data is too long shaStateError constant returned by each function when SHA$$$Input is called after SHA$$$FinalBits or SHA$$$Result.

   Structure:
      typedef SHA$$$Context
                          an opaque structure holding the complete state
                          for producing the hash

Structure: typedef SHA$$$Context an opaque structure holding the complete state for producing the hash

   Functions:
                  int SHA$$$Reset(SHA$$$Context *);
            Reset the hash context state
      int SHA$$$Input(SHA$$$Context *, const uint8_t *octets,
                  unsigned int bytecount);
            Incorporate bytecount octets into the hash.
      int SHA$$$FinalBits(SHA$$$Context *, const uint8_t octet,
                  unsigned int bitcount);
            Incorporate bitcount bits into the hash.  The bits are in
            the upper portion of the octet.  SHA$$$Input() cannot be
            called after this.
      int SHA$$$Result(SHA$$$Context *,
                  uint8_t Message_Digest[SHA$$$HashSize]);
            Do the final calculations on the hash and copy the value
            into Message_Digest.

Functions: int SHA$$$Reset(SHA$$$Context *); Reset the hash context state int SHA$$$Input(SHA$$$Context *, const uint8_t *octets, unsigned int bytecount); Incorporate bytecount octets into the hash. int SHA$$$FinalBits(SHA$$$Context *, const uint8_t octet, unsigned int bitcount); Incorporate bitcount bits into the hash. The bits are in the upper portion of the octet. SHA$$$Input() cannot be called after this. int SHA$$$Result(SHA$$$Context *, uint8_t Message_Digest[SHA$$$HashSize]); Do the final calculations on the hash and copy the value into Message_Digest.

   In addition, functions with the prefix USHA are provided that take a
   SHAversion value (SHA$$$) to select the SHA function suite.  They add
   the following constants, structure, and functions:

In addition, functions with the prefix USHA are provided that take a SHAversion value (SHA$$$) to select the SHA function suite. They add the following constants, structure, and functions:

   Constants:
      shaBadParam         constant returned by USHA functions when
                          presented with a bad SHAversion (SHA$$$)
                          parameter

Constants: shaBadParam constant returned by USHA functions when presented with a bad SHAversion (SHA$$$) parameter

Eastlake 3rd & Hansen        Informational                     [Page 16]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 16] RFC 4634 SHAs and HMAC-SHAs July 2006

      SHA$$$              SHAversion enumeration values, used by usha
                          and hmac functions to select the SHA function
                          suite

SHA$$$ SHAversion enumeration values, used by usha and hmac functions to select the SHA function suite

   Structure:
      typedef USHAContext
                          an opaque structure holding the complete state
                          for producing the hash

Structure: typedef USHAContext an opaque structure holding the complete state for producing the hash

   Functions:
      int USHAReset(USHAContext *, SHAversion whichSha);
            Reset the hash context state.
      int USHAInput(USHAContext *,
                  const uint8_t *bytes, unsigned int bytecount);
            Incorporate bytecount octets into the hash.
      int USHAFinalBits(USHAContext *,
                  const uint8_t bits, unsigned int bitcount);
                  Incorporate bitcount bits into the hash.
      int USHAResult(USHAContext *,
                  uint8_t Message_Digest[USHAMaxHashSize]);
            Do the final calculations on the hash and copy the value
            into Message_Digest.  Octets in Message_Digest beyond
      USHAHashSize(whichSha) are left untouched.
                  int USHAHashSize(enum SHAversion whichSha);
            The number of octets in the given hash.
      int USHAHashSizeBits(enum SHAversion whichSha);
            The number of bits in the given hash.
      int USHABlockSize(enum SHAversion whichSha);
            The internal block size for the given hash.

Functions: int USHAReset(USHAContext *, SHAversion whichSha); Reset the hash context state. int USHAInput(USHAContext *, const uint8_t *bytes, unsigned int bytecount); Incorporate bytecount octets into the hash. int USHAFinalBits(USHAContext *, const uint8_t bits, unsigned int bitcount); Incorporate bitcount bits into the hash. int USHAResult(USHAContext *, uint8_t Message_Digest[USHAMaxHashSize]); Do the final calculations on the hash and copy the value into Message_Digest. Octets in Message_Digest beyond USHAHashSize(whichSha) are left untouched. int USHAHashSize(enum SHAversion whichSha); The number of octets in the given hash. int USHAHashSizeBits(enum SHAversion whichSha); The number of bits in the given hash. int USHABlockSize(enum SHAversion whichSha); The internal block size for the given hash.

   The hmac functions follow the same pattern to allow any length of
   text input to be used.

The hmac functions follow the same pattern to allow any length of text input to be used.

   Structure:
      typedef HMACContext an opaque structure holding the complete state
                          for producing the hash

Structure: typedef HMACContext an opaque structure holding the complete state for producing the hash

   Functions:
      int hmacReset(HMACContext *ctx, enum SHAversion whichSha,
                  const unsigned char *key, int key_len);
            Reset the hash context state.
      int hmacInput(HMACContext *ctx, const unsigned char *text,
                  int text_len);
            Incorporate text_len octets into the hash.
      int hmacFinalBits(HMACContext *ctx, const uint8_t bits,
                  unsigned int bitcount);
            Incorporate bitcount bits into the hash.

Functions: int hmacReset(HMACContext *ctx, enum SHAversion whichSha, const unsigned char *key, int key_len); Reset the hash context state. int hmacInput(HMACContext *ctx, const unsigned char *text, int text_len); Incorporate text_len octets into the hash. int hmacFinalBits(HMACContext *ctx, const uint8_t bits, unsigned int bitcount); Incorporate bitcount bits into the hash.

Eastlake 3rd & Hansen        Informational                     [Page 17]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 17] RFC 4634 SHAs and HMAC-SHAs July 2006

      int hmacResult(HMACContext *ctx,
                  uint8_t Message_Digest[USHAMaxHashSize]);
            Do the final calculations on the hash and copy the value
            into Message_Digest.  Octets in Message_Digest beyond
            USHAHashSize(whichSha) are left untouched.

int hmacResult(HMACContext *ctx, uint8_t Message_Digest[USHAMaxHashSize]); Do the final calculations on the hash and copy the value into Message_Digest. Octets in Message_Digest beyond USHAHashSize(whichSha) are left untouched.

   In addition, a combined interface is provided, similar to that shown
   in RFC 2104, that allows a fixed-length text input to be used.

In addition, a combined interface is provided, similar to that shown in RFC 2104, that allows a fixed-length text input to be used.

      int hmac(SHAversion whichSha,
                  const unsigned char *text, int text_len,
                  const unsigned char *key, int key_len,
                  uint8_t Message_Digest[USHAMaxHashSize]);
            Calculate the given digest for the given text and key, and
            return the resulting hash.  Octets in Message_Digest beyond
            USHAHashSize(whichSha) are left untouched.

int hmac(SHAversion whichSha, const unsigned char *text, int text_len, const unsigned char *key, int key_len, uint8_t Message_Digest[USHAMaxHashSize]); Calculate the given digest for the given text and key, and return the resulting hash. Octets in Message_Digest beyond USHAHashSize(whichSha) are left untouched.

8.1.  The .h File

8.1. The .h File

/**************************** sha.h ****************************/
/******************* See RFC 4634 for details ******************/
#ifndef _SHA_H_
#define _SHA_H_

/**************************** sha.h ****************************/ /******************* See RFC 4634 for details ******************/ #ifndef _SHA_H_ #define _SHA_H_

/*
 *  Description:
 *      This file implements the Secure Hash Signature Standard
 *      algorithms as defined in the National Institute of Standards
 *      and Technology Federal Information Processing Standards
 *      Publication (FIPS PUB) 180-1 published on April 17, 1995, 180-2
 *      published on August 1, 2002, and the FIPS PUB 180-2 Change
 *      Notice published on February 28, 2004.
 *
 *      A combined document showing all algorithms is available at
 *              http://csrc.nist.gov/publications/fips/
 *              fips180-2/fips180-2withchangenotice.pdf
 *
 *      The five hashes are defined in these sizes:
 *              SHA-1           20 byte / 160 bit
 *              SHA-224         28 byte / 224 bit
 *              SHA-256         32 byte / 256 bit
 *              SHA-384         48 byte / 384 bit
 *              SHA-512         64 byte / 512 bit
 */

/* * Description: * This file implements the Secure Hash Signature Standard * algorithms as defined in the National Institute of Standards * and Technology Federal Information Processing Standards * Publication (FIPS PUB) 180-1 published on April 17, 1995, 180-2 * published on August 1, 2002, and the FIPS PUB 180-2 Change * Notice published on February 28, 2004. * * A combined document showing all algorithms is available at * http://csrc.nist.gov/publications/fips/ * fips180-2/fips180-2withchangenotice.pdf * * The five hashes are defined in these sizes: * SHA-1 20 byte / 160 bit * SHA-224 28 byte / 224 bit * SHA-256 32 byte / 256 bit * SHA-384 48 byte / 384 bit * SHA-512 64 byte / 512 bit */

#include <stdint.h>
/*
 * If you do not have the ISO standard stdint.h header file, then you

#include <stdint.h> /* * If you do not have the ISO standard stdint.h header file, then you

Eastlake 3rd & Hansen        Informational                     [Page 18]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 18] RFC 4634 SHAs and HMAC-SHAs July 2006

 * must typedef the following:
 *    name              meaning
 *  uint64_t         unsigned 64 bit integer
 *  uint32_t         unsigned 32 bit integer
 *  uint8_t          unsigned 8 bit integer (i.e., unsigned char)
 *  int_least16_t    integer of >= 16 bits
 *
 */

* must typedef the following: * name meaning * uint64_t unsigned 64 bit integer * uint32_t unsigned 32 bit integer * uint8_t unsigned 8 bit integer (i.e., unsigned char) * int_least16_t integer of >= 16 bits * */

#ifndef _SHA_enum_
#define _SHA_enum_
/*
 *  All SHA functions return one of these values.
 */
enum {
    shaSuccess = 0,
    shaNull,            /* Null pointer parameter */
    shaInputTooLong,    /* input data too long */
    shaStateError,      /* called Input after FinalBits or Result */
    shaBadParam         /* passed a bad parameter */
};
#endif /* _SHA_enum_ */

#ifndef _SHA_enum_ #define _SHA_enum_ /* * All SHA functions return one of these values. */ enum { shaSuccess = 0, shaNull, /* Null pointer parameter */ shaInputTooLong, /* input data too long */ shaStateError, /* called Input after FinalBits or Result */ shaBadParam /* passed a bad parameter */ }; #endif /* _SHA_enum_ */

/*
 *  These constants hold size information for each of the SHA
 *  hashing operations
 */
enum {
    SHA1_Message_Block_Size = 64, SHA224_Message_Block_Size = 64,
    SHA256_Message_Block_Size = 64, SHA384_Message_Block_Size = 128,
    SHA512_Message_Block_Size = 128,
    USHA_Max_Message_Block_Size = SHA512_Message_Block_Size,

/* * These constants hold size information for each of the SHA * hashing operations */ enum { SHA1_Message_Block_Size = 64, SHA224_Message_Block_Size = 64, SHA256_Message_Block_Size = 64, SHA384_Message_Block_Size = 128, SHA512_Message_Block_Size = 128, USHA_Max_Message_Block_Size = SHA512_Message_Block_Size,

    SHA1HashSize = 20, SHA224HashSize = 28, SHA256HashSize = 32,
    SHA384HashSize = 48, SHA512HashSize = 64,
    USHAMaxHashSize = SHA512HashSize,

SHA1HashSize = 20, SHA224HashSize = 28, SHA256HashSize = 32, SHA384HashSize = 48, SHA512HashSize = 64, USHAMaxHashSize = SHA512HashSize,

    SHA1HashSizeBits = 160, SHA224HashSizeBits = 224,
    SHA256HashSizeBits = 256, SHA384HashSizeBits = 384,
    SHA512HashSizeBits = 512, USHAMaxHashSizeBits = SHA512HashSizeBits
};

SHA1HashSizeBits = 160, SHA224HashSizeBits = 224, SHA256HashSizeBits = 256, SHA384HashSizeBits = 384, SHA512HashSizeBits = 512, USHAMaxHashSizeBits = SHA512HashSizeBits };

/*
 *  These constants are used in the USHA (unified sha) functions.
 */
typedef enum SHAversion {
    SHA1, SHA224, SHA256, SHA384, SHA512
} SHAversion;

/* * These constants are used in the USHA (unified sha) functions. */ typedef enum SHAversion { SHA1, SHA224, SHA256, SHA384, SHA512 } SHAversion;

Eastlake 3rd & Hansen        Informational                     [Page 19]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 19] RFC 4634 SHAs and HMAC-SHAs July 2006

/*
 *  This structure will hold context information for the SHA-1
 *  hashing operation.
 */
typedef struct SHA1Context {
    uint32_t Intermediate_Hash[SHA1HashSize/4]; /* Message Digest */

/* * This structure will hold context information for the SHA-1 * hashing operation. */ typedef struct SHA1Context { uint32_t Intermediate_Hash[SHA1HashSize/4]; /* Message Digest */

    uint32_t Length_Low;                /* Message length in bits */
    uint32_t Length_High;               /* Message length in bits */

uint32_t Length_Low; /* Message length in bits */ uint32_t Length_High; /* Message length in bits */

    int_least16_t Message_Block_Index;  /* Message_Block array index */
                                        /* 512-bit message blocks */
    uint8_t Message_Block[SHA1_Message_Block_Size];

int_least16_t Message_Block_Index; /* Message_Block array index */ /* 512-bit message blocks */ uint8_t Message_Block[SHA1_Message_Block_Size];

    int Computed;                       /* Is the digest computed? */
    int Corrupted;                      /* Is the digest corrupted? */
} SHA1Context;

int Computed; /* Is the digest computed? */ int Corrupted; /* Is the digest corrupted? */ } SHA1Context;

/*
 *  This structure will hold context information for the SHA-256
 *  hashing operation.
 */
typedef struct SHA256Context {
    uint32_t Intermediate_Hash[SHA256HashSize/4]; /* Message Digest */

/* * This structure will hold context information for the SHA-256 * hashing operation. */ typedef struct SHA256Context { uint32_t Intermediate_Hash[SHA256HashSize/4]; /* Message Digest */

    uint32_t Length_Low;                /* Message length in bits */
    uint32_t Length_High;               /* Message length in bits */

uint32_t Length_Low; /* Message length in bits */ uint32_t Length_High; /* Message length in bits */

    int_least16_t Message_Block_Index;  /* Message_Block array index */
                                        /* 512-bit message blocks */
    uint8_t Message_Block[SHA256_Message_Block_Size];

int_least16_t Message_Block_Index; /* Message_Block array index */ /* 512-bit message blocks */ uint8_t Message_Block[SHA256_Message_Block_Size];

    int Computed;                       /* Is the digest computed? */
    int Corrupted;                      /* Is the digest corrupted? */
} SHA256Context;

int Computed; /* Is the digest computed? */ int Corrupted; /* Is the digest corrupted? */ } SHA256Context;

/*
 *  This structure will hold context information for the SHA-512
 *  hashing operation.
 */
typedef struct SHA512Context {
#ifdef USE_32BIT_ONLY
    uint32_t Intermediate_Hash[SHA512HashSize/4]; /* Message Digest  */
    uint32_t Length[4];                 /* Message length in bits */
#else /* !USE_32BIT_ONLY */
    uint64_t Intermediate_Hash[SHA512HashSize/8]; /* Message Digest */
    uint64_t Length_Low, Length_High;   /* Message length in bits */
#endif /* USE_32BIT_ONLY */

/* * This structure will hold context information for the SHA-512 * hashing operation. */ typedef struct SHA512Context { #ifdef USE_32BIT_ONLY uint32_t Intermediate_Hash[SHA512HashSize/4]; /* Message Digest */ uint32_t Length[4]; /* Message length in bits */ #else /* !USE_32BIT_ONLY */ uint64_t Intermediate_Hash[SHA512HashSize/8]; /* Message Digest */ uint64_t Length_Low, Length_High; /* Message length in bits */ #endif /* USE_32BIT_ONLY */

Eastlake 3rd & Hansen        Informational                     [Page 20]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 20] RFC 4634 SHAs and HMAC-SHAs July 2006

    int_least16_t Message_Block_Index;  /* Message_Block array index */
                                        /* 1024-bit message blocks */
    uint8_t Message_Block[SHA512_Message_Block_Size];

int_least16_t Message_Block_Index; /* Message_Block array index */ /* 1024-bit message blocks */ uint8_t Message_Block[SHA512_Message_Block_Size];

    int Computed;                       /* Is the digest computed?*/
    int Corrupted;                      /* Is the digest corrupted? */
} SHA512Context;

int Computed; /* Is the digest computed?*/ int Corrupted; /* Is the digest corrupted? */ } SHA512Context;

/*
 *  This structure will hold context information for the SHA-224
 *  hashing operation. It uses the SHA-256 structure for computation.
 */
typedef struct SHA256Context SHA224Context;

/* * This structure will hold context information for the SHA-224 * hashing operation. It uses the SHA-256 structure for computation. */ typedef struct SHA256Context SHA224Context;

/*
 *  This structure will hold context information for the SHA-384
 *  hashing operation. It uses the SHA-512 structure for computation.
 */
typedef struct SHA512Context SHA384Context;

/* * This structure will hold context information for the SHA-384 * hashing operation. It uses the SHA-512 structure for computation. */ typedef struct SHA512Context SHA384Context;

/*
 *  This structure holds context information for all SHA
 *  hashing operations.
 */
typedef struct USHAContext {
    int whichSha;               /* which SHA is being used */
    union {
      SHA1Context sha1Context;
      SHA224Context sha224Context; SHA256Context sha256Context;
      SHA384Context sha384Context; SHA512Context sha512Context;
    } ctx;
} USHAContext;

/* * This structure holds context information for all SHA * hashing operations. */ typedef struct USHAContext { int whichSha; /* which SHA is being used */ union { SHA1Context sha1Context; SHA224Context sha224Context; SHA256Context sha256Context; SHA384Context sha384Context; SHA512Context sha512Context; } ctx; } USHAContext;

/*
 *  This structure will hold context information for the HMAC
 *  keyed hashing operation.
 */
typedef struct HMACContext {
    int whichSha;               /* which SHA is being used */
    int hashSize;               /* hash size of SHA being used */
    int blockSize;              /* block size of SHA being used */
    USHAContext shaContext;     /* SHA context */
    unsigned char k_opad[USHA_Max_Message_Block_Size];
                        /* outer padding - key XORd with opad */
} HMACContext;

/* * This structure will hold context information for the HMAC * keyed hashing operation. */ typedef struct HMACContext { int whichSha; /* which SHA is being used */ int hashSize; /* hash size of SHA being used */ int blockSize; /* block size of SHA being used */ USHAContext shaContext; /* SHA context */ unsigned char k_opad[USHA_Max_Message_Block_Size]; /* outer padding - key XORd with opad */ } HMACContext;

Eastlake 3rd & Hansen        Informational                     [Page 21]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 21] RFC 4634 SHAs and HMAC-SHAs July 2006

/*
 *  Function Prototypes
 */

/* * Function Prototypes */

/* SHA-1 */
extern int SHA1Reset(SHA1Context *);
extern int SHA1Input(SHA1Context *, const uint8_t *bytes,
                     unsigned int bytecount);
extern int SHA1FinalBits(SHA1Context *, const uint8_t bits,
                         unsigned int bitcount);
extern int SHA1Result(SHA1Context *,
                      uint8_t Message_Digest[SHA1HashSize]);

/* SHA-1 */ extern int SHA1Reset(SHA1Context *); extern int SHA1Input(SHA1Context *, const uint8_t *bytes, unsigned int bytecount); extern int SHA1FinalBits(SHA1Context *, const uint8_t bits, unsigned int bitcount); extern int SHA1Result(SHA1Context *, uint8_t Message_Digest[SHA1HashSize]);

/* SHA-224 */
extern int SHA224Reset(SHA224Context *);
extern int SHA224Input(SHA224Context *, const uint8_t *bytes,
                       unsigned int bytecount);
extern int SHA224FinalBits(SHA224Context *, const uint8_t bits,
                           unsigned int bitcount);
extern int SHA224Result(SHA224Context *,
                        uint8_t Message_Digest[SHA224HashSize]);

/* SHA-224 */ extern int SHA224Reset(SHA224Context *); extern int SHA224Input(SHA224Context *, const uint8_t *bytes, unsigned int bytecount); extern int SHA224FinalBits(SHA224Context *, const uint8_t bits, unsigned int bitcount); extern int SHA224Result(SHA224Context *, uint8_t Message_Digest[SHA224HashSize]);

/* SHA-256 */
extern int SHA256Reset(SHA256Context *);
extern int SHA256Input(SHA256Context *, const uint8_t *bytes,
                       unsigned int bytecount);
extern int SHA256FinalBits(SHA256Context *, const uint8_t bits,
                           unsigned int bitcount);
extern int SHA256Result(SHA256Context *,
                        uint8_t Message_Digest[SHA256HashSize]);

/* SHA-256 */ extern int SHA256Reset(SHA256Context *); extern int SHA256Input(SHA256Context *, const uint8_t *bytes, unsigned int bytecount); extern int SHA256FinalBits(SHA256Context *, const uint8_t bits, unsigned int bitcount); extern int SHA256Result(SHA256Context *, uint8_t Message_Digest[SHA256HashSize]);

/* SHA-384 */
extern int SHA384Reset(SHA384Context *);
extern int SHA384Input(SHA384Context *, const uint8_t *bytes,
                       unsigned int bytecount);
extern int SHA384FinalBits(SHA384Context *, const uint8_t bits,
                           unsigned int bitcount);
extern int SHA384Result(SHA384Context *,
                        uint8_t Message_Digest[SHA384HashSize]);

/* SHA-384 */ extern int SHA384Reset(SHA384Context *); extern int SHA384Input(SHA384Context *, const uint8_t *bytes, unsigned int bytecount); extern int SHA384FinalBits(SHA384Context *, const uint8_t bits, unsigned int bitcount); extern int SHA384Result(SHA384Context *, uint8_t Message_Digest[SHA384HashSize]);

/* SHA-512 */
extern int SHA512Reset(SHA512Context *);
extern int SHA512Input(SHA512Context *, const uint8_t *bytes,
                       unsigned int bytecount);
extern int SHA512FinalBits(SHA512Context *, const uint8_t bits,
                           unsigned int bitcount);
extern int SHA512Result(SHA512Context *,
                        uint8_t Message_Digest[SHA512HashSize]);

/*SHA-512*/通いの人int SHA512Reset(SHA512Context*)。 通いの人int SHA512Input(SHA512Context*、const uint8_t*バイト、無記名のint bytecount)。 通いの人int SHA512FinalBits(SHA512Context*、const uint8_tビット、無記名のint bitcount)。 通いの人int SHA512Result(SHA512Context*、uint8_t Message_Digest[SHA512HashSize])。

Eastlake 3rd & Hansen        Informational                     [Page 22]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[22ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

/* Unified SHA functions, chosen by whichSha */
extern int USHAReset(USHAContext *, SHAversion whichSha);
extern int USHAInput(USHAContext *,
                     const uint8_t *bytes, unsigned int bytecount);
extern int USHAFinalBits(USHAContext *,
                         const uint8_t bits, unsigned int bitcount);
extern int USHAResult(USHAContext *,
                      uint8_t Message_Digest[USHAMaxHashSize]);
extern int USHABlockSize(enum SHAversion whichSha);
extern int USHAHashSize(enum SHAversion whichSha);
extern int USHAHashSizeBits(enum SHAversion whichSha);

/*はwhichSha*/通いの人int USHAReset(USHAContext*、SHAversion whichSha)によって選ばれたSHA機能を統一しました。 通いの人int USHAInput(USHAContext*、const uint8_t*バイト、無記名のint bytecount)。 通いの人int USHAFinalBits(USHAContext*、const uint8_tビット、無記名のint bitcount)。 通いの人int USHAResult(USHAContext*、uint8_t Message_Digest[USHAMaxHashSize])。 通いの人int USHABlockSize(enum SHAversion whichSha)。 通いの人int USHAHashSize(enum SHAversion whichSha)。 通いの人int USHAHashSizeBits(enum SHAversion whichSha)。

/*
 * HMAC Keyed-Hashing for Message Authentication, RFC2104,
 * for all SHAs.
 * This interface allows a fixed-length text input to be used.
 */
extern int hmac(SHAversion whichSha, /* which SHA algorithm to use */
    const unsigned char *text,     /* pointer to data stream */
    int text_len,                  /* length of data stream */
    const unsigned char *key,      /* pointer to authentication key */
    int key_len,                   /* length of authentication key */
    uint8_t digest[USHAMaxHashSize]); /* caller digest to fill in */

Message Authenticationのための/**HMAC Keyed-論じ尽くすRFC2104、すべてのSHAsのための*。 * このインタフェースは、固定長テキスト入力が使用されるのを許容します。 */通いの人int hmac(SHAversion whichSha、それのSHAアルゴリズムが*テキストを使用*/const無記名に炭にする/*、データ・ストリーム*/intテキスト_len、データ・ストリームの*/constの無記名の炭*キー、認証主要な*/intキー_len、認証主要な*/uint8_tダイジェスト[USHAMaxHashSize]の/*長さへの/*ポインタの/*長さへの/*ポインタ)。 */に記入する/*訪問者ダイジェスト

/*
 * HMAC Keyed-Hashing for Message Authentication, RFC2104,
 * for all SHAs.
 * This interface allows any length of text input to be used.
 */
extern int hmacReset(HMACContext *ctx, enum SHAversion whichSha,
                     const unsigned char *key, int key_len);
extern int hmacInput(HMACContext *ctx, const unsigned char *text,
                     int text_len);

Message Authenticationのための/**HMAC Keyed-論じ尽くすRFC2104、すべてのSHAsのための*。 * このインタフェースは使用されるために入力されたどんな長さのテキストも許容します。 */通いの人int hmacReset(HMACContext*ctx、enum SHAversion whichSha、主要なconstの無記名の炭*のintキー_len)。 通いの人int hmacInput(HMACContext*ctx、constの無記名の炭*テキスト、intテキスト_len)。

extern int hmacFinalBits(HMACContext *ctx, const uint8_t bits,
                         unsigned int bitcount);
extern int hmacResult(HMACContext *ctx,
                      uint8_t digest[USHAMaxHashSize]);

通いの人int hmacFinalBits(HMACContext*ctx、const uint8_tビット、無記名のint bitcount)。 通いの人int hmacResult(HMACContext*ctx、uint8_tダイジェスト[USHAMaxHashSize])。

#endif /* _SHA_H_ */

#endif /* _SHA_H_ */

Eastlake 3rd & Hansen        Informational                     [Page 23]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[23ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

8.2.  The SHA Code

8.2. SHAコード

   This code is primarily intended as expository and could be optimized
   further.  For example, the assignment rotations through the variables
   a, b, ..., h could be treated as a cycle and the loop unrolled,
   rather than doing the explicit copying.

このコードは、解説として主として意図して、さらに最適化できました。 例えば、変数a、bを通した課題回転…, 1サイクルと輪が明白なコピーをするよりむしろ広げられたとき、hを扱うことができました。

   Note that there are alternative representations of the Ch() and Maj()
   functions controlled by an ifdef.

ifdefによって制御されたCh()とマイ()機能の代替の表現があることに注意してください。

8.2.1.  sha1.c

8.2.1. sha1.c

/**************************** sha1.c ****************************/
/******************** See RFC 4634 for details ******************/
/*
 *  Description:
 *      This file implements the Secure Hash Signature Standard
 *      algorithms as defined in the National Institute of Standards
 *      and Technology Federal Information Processing Standards
 *      Publication (FIPS PUB) 180-1 published on April 17, 1995, 180-2
 *      published on August 1, 2002, and the FIPS PUB 180-2 Change
 *      Notice published on February 28, 2004.
 *
 *      A combined document showing all algorithms is available at
 *              http://csrc.nist.gov/publications/fips/
 *              fips180-2/fips180-2withchangenotice.pdf
 *
 *      The SHA-1 algorithm produces a 160-bit message digest for a
 *      given data stream.  It should take about 2**n steps to find a
 *      message with the same digest as a given message and
 *      2**(n/2) to find any two messages with the same digest,
 *      when n is the digest size in bits.  Therefore, this
 *      algorithm can serve as a means of providing a
 *      "fingerprint" for a message.
 *
 *  Portability Issues:
 *      SHA-1 is defined in terms of 32-bit "words".  This code
 *      uses <stdint.h> (included via "sha.h") to define 32 and 8
 *      bit unsigned integer types.  If your C compiler does not
 *      support 32 bit unsigned integers, this code is not
 *      appropriate.
 *
 *  Caveats:
 *      SHA-1 is designed to work with messages less than 2^64 bits
 *      long. This implementation uses SHA1Input() to hash the bits
 *      that are a multiple of the size of an 8-bit character, and then
 *      uses SHA1FinalBits() to hash the final few bits of the input.
 */

見る..詳細..記述 * このファイルはStandards*のNational Instituteで定義されるSecure Hash Signature Standard*アルゴリズム、1995年4月17日に発行された、Technology連邦政府の情報Processing Standards*公表(FIPS PUB)180-1、2002年8月1日に発行された180-2*、および2004年2月28日に発表されたFIPS PUB180-2Change*通知を実行します。 * * すべてのアルゴリズムを示している結合したドキュメントは* http://csrc.nist.gov/publications/fips/ *fips180-2/fips180-2withchangenotice.pdfで利用可能です。**データ・ストリームを考えて、SHA-1アルゴリズムは*のために160ビットのメッセージダイジェストを作成します。 それは2時頃に同じダイジェストでどんな2つのメッセージも見つけるために与えられたメッセージと*2**(n/2)と同じダイジェストで*メッセージを見つけるには**nステップでかかるべきです、*nがビットのダイジェストサイズであるときに。 したがって、この*アルゴリズムは*「指紋」をメッセージに提供する手段として機能できます。 * * 移植性の問題: * SHA-1は32ビットの「単語」で定義されます。 このコード*は、32と8*ビット符号のない整数タイプを定義するのに、<stdint.h>("sha.h"を通して、含まれている)を使用します。 あなたのCコンパイラがどんな*もしないなら、サポート32は符号のない整数に噛み付いて、このコードは*適切ではありません。 * * 警告: * SHA-1は、*長い間メッセージで2未満^を64ビット扱うように設計されています。 この実現は8ビットのキャラクタのサイズの倍数であるビット*を論じ尽くすのにSHA1Input()を使用します、そして、次に、*は入力の最終的な数ビットしか論じ尽くさないようにSHA1FinalBits()を使用します。 */

Eastlake 3rd & Hansen        Informational                     [Page 24]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[24ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

#include "sha.h"
#include "sha-private.h"

##、が含む"sha.h""sha-private.h"を含めてください。

/*
 *  Define the SHA1 circular left shift macro
 */
#define SHA1_ROTL(bits,word) \
                (((word) << (bits)) | ((word) >> (32-(bits))))

/**が定義する、左のSHA1円形のシフトマクロ*/#、はSHA1_ROTL(ビット、単語)\を定義します。((単語)<<(ビット))| ((単語)>>(32(ビット)))

/*
 * add "length" to the length
 */
static uint32_t addTemp;
#define SHA1AddLength(context, length)                     \
    (addTemp = (context)->Length_Low,                      \
     (context)->Corrupted =                                \
        (((context)->Length_Low += (length)) < addTemp) && \
        (++(context)->Length_High == 0) ? 1 : 0)

/**は長さ*/静的なuint32_t addTempに「長さ」を加えます。 #SHA1AddLength(文脈、長さ)\を定義してください。(addTemp=(文脈)、->長さ_安値、\(文脈)->が=\((文脈)>長さ_安値+=(長さ)<addTemp)を崩壊させた、\、(+ + (文脈)、-、>長さ_高い=0?)の1:0)

/* Local Function Prototypes */
static void SHA1Finalize(SHA1Context *context, uint8_t Pad_Byte);
static void SHA1PadMessage(SHA1Context *, uint8_t Pad_Byte);
static void SHA1ProcessMessageBlock(SHA1Context *);

/*地方のFunction Prototypes*/静電気はSHA1Finalize(SHA1Context*文脈、uint8_t Pad_Byte)を欠如させます。 静的な空のSHA1PadMessage(SHA1Context*、uint8_t Pad_Byte)。 静的な空のSHA1ProcessMessageBlock(SHA1Context*)。

/*
 *  SHA1Reset
 *
 *  Description:
 *      This function will initialize the SHA1Context in preparation
 *      for computing a new SHA1 message digest.
 *
 *  Parameters:
 *      context: [in/out]
 *          The context to reset.
 *
 *  Returns:
 *      sha Error Code.
 *
 */
int SHA1Reset(SHA1Context *context)
{
    if (!context)
        return shaNull;

/**SHA1Reset**記述: * この機能は新しいSHA1メッセージダイジェストを計算するための準備*でSHA1Contextを初期化するでしょう。 * * パラメタ: * 文脈: [/アウト] *のリセットする文脈。 * * リターン: * sha Error Code。 * */int SHA1Reset(SHA1Context*文脈)、(文脈)であるなら、shaNullを返してください。

    context->Length_Low             = 0;
    context->Length_High            = 0;
    context->Message_Block_Index    = 0;

文脈、->長さ_安値は0と等しいです。 文脈、->長さ_高値は0と等しいです。 メッセージ_ブロック_が索引をつける文脈->は0と等しいです。

Eastlake 3rd & Hansen        Informational                     [Page 25]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[25ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

    /* Initial Hash Values: FIPS-180-2 section 5.3.1 */
    context->Intermediate_Hash[0]   = 0x67452301;
    context->Intermediate_Hash[1]   = 0xEFCDAB89;
    context->Intermediate_Hash[2]   = 0x98BADCFE;
    context->Intermediate_Hash[3]   = 0x10325476;
    context->Intermediate_Hash[4]   = 0xC3D2E1F0;

/*初期のハッシュ値: FIPS-180-2部5.3 .1 文脈*/>Intermediate_Hash[0]=0x67452301。 文脈->中間的な_細切れ肉料理[1]は0xEFCDAB89と等しいです。 文脈->中間的な_細切れ肉料理[2]は0x98BADCFEと等しいです。 文脈->中間的な_細切れ肉料理[3]=0×10325476。 文脈->中間的な_細切れ肉料理[4]は0xC3D2E1F0と等しいです。

    context->Computed   = 0;
    context->Corrupted  = 0;

文脈->が計算された=0。 文脈->が崩壊している=0。

    return shaSuccess;
}

shaSuccessを返してください。 }

/*
 *  SHA1Input
 *
 *  Description:
 *      This function accepts an array of octets as the next portion
 *      of the message.
 *
 *  Parameters:
 *      context: [in/out]
 *          The SHA context to update
 *      message_array: [in]
 *          An array of characters representing the next portion of
 *          the message.
 *      length: [in]
 *          The length of the message in message_array
 *
 *  Returns:
 *      sha Error Code.
 *
 */
int SHA1Input(SHA1Context *context,
    const uint8_t *message_array, unsigned length)
{
  if (!length)
    return shaSuccess;

/**SHA1Input**記述: * この機能はメッセージの次の部分*として八重奏の勢ぞろいを認めます。 * * パラメタ: * 文脈: アップデート*メッセージ_へのSHA文脈が整列させる[コネ/アウト]*: *次を表すキャラクタのアレイは*を分配します。[in]、メッセージ。 * 長さ: メッセージ_アレイ**のメッセージの長さの[in]*は戻ります: * sha Error Code。 * */int SHA1Input(SHA1Context*文脈、const uint8_t*は_アレイ、無記名の長さを通信させる)、(長さ)であるなら、shaSuccessを返してください。

  if (!context || !message_array)
    return shaNull;

(メッセージ_アレイ| 文脈| )であるなら、shaNullを返してください。

  if (context->Computed) {
    context->Corrupted = shaStateError;
    return shaStateError;
  }

(文脈->は計算されていました)文脈、->CorruptedはshaStateErrorと等しいです; リターンshaStateError

  if (context->Corrupted)

if(文脈->は崩壊していました)です。

Eastlake 3rd & Hansen        Informational                     [Page 26]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[26ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

     return context->Corrupted;

文脈->にCorruptedを返してください。

  while (length-- && !context->Corrupted) {
    context->Message_Block[context->Message_Block_Index++] =
      (*message_array & 0xFF);

(長さ、--、崩壊する文脈->、)、文脈->は_ブロック[文脈->は_ブロック_インデックス++を通信させる]=(*メッセージ_アレイと0xFF)を通信させます。

    if (!SHA1AddLength(context, 8) &&
      (context->Message_Block_Index == SHA1_Message_Block_Size))
      SHA1ProcessMessageBlock(context);

(SHA1AddLength(文脈、8)、(文脈->は_ブロック_インデックス=SHA1_メッセージ_ブロック_サイズを通信させます)) SHA1ProcessMessageBlock(文脈)。

    message_array++;
  }

メッセージ_アレイ++。 }

  return shaSuccess;
}

shaSuccessを返してください。 }

/*
 * SHA1FinalBits
 *
 * Description:
 *   This function will add in any final bits of the message.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   message_bits: [in]
 *     The final bits of the message, in the upper portion of the
 *     byte. (Use 0b###00000 instead of 0b00000### to input the
 *     three bits ###.)
 *   length: [in]
 *     The number of bits in message_bits, between 1 and 7.
 *
 * Returns:
 *   sha Error Code.
 */
int SHA1FinalBits(SHA1Context *context, const uint8_t message_bits,
    unsigned int length)
{
  uint8_t masks[8] = {
      /* 0 0b00000000 */ 0x00, /* 1 0b10000000 */ 0x80,
      /* 2 0b11000000 */ 0xC0, /* 3 0b11100000 */ 0xE0,
      /* 4 0b11110000 */ 0xF0, /* 5 0b11111000 */ 0xF8,
      /* 6 0b11111100 */ 0xFC, /* 7 0b11111110 */ 0xFE
  };
  uint8_t markbit[8] = {
      /* 0 0b10000000 */ 0x80, /* 1 0b01000000 */ 0x40,
      /* 2 0b00100000 */ 0x20, /* 3 0b00010000 */ 0x10,
      /* 4 0b00001000 */ 0x08, /* 5 0b00000100 */ 0x04,

/**SHA1FinalBits**記述: * この機能はメッセージのどんな最終的なビットも加えるでしょう。 * * パラメタ: * 文脈: [コネ/アウト] **をアップデートするSHA文脈は_ビットを通信させます: [in]*、*バイトの上部のメッセージの最終的なビット。 (0b00000###の代わりに0b###00000、を使用して、*3ビット###、を入力してください。) * 長さ: [in]*はメッセージ_ビット、1〜7で、ビットの数です。 * * リターン: * sha Error Code。 */int SHA1FinalBits(SHA1Context*文脈、const uint8_tは_ビットを通信させます、無記名のintの長さ)、uint8_tマスク[8]は/*0 0b00000000*/0x00、/*1 0b10000000*/0x80、/*2 0b11000000*/0xC0、/*3 0b11100000*/0xE0、/*4 0b11110000*/0xF0、/*5 0b11111000*/0xF8、/*6 0b11111100*/0xFC、/*7 0b11111110*/0xFEと等しいです;、uint8_t markbit[8]が等しい、/*0 0b10000000*/0x80、/*1 0b01000000*/0x40、/*2 0b00100000*/0x20、/*3 0b00010000*/0x10、/*4 0b00001000*/0x08、/*5 0b00000100*/0x04

Eastlake 3rd & Hansen        Informational                     [Page 27]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[27ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

      /* 6 0b00000010 */ 0x02, /* 7 0b00000001 */ 0x01
  };

/*6 0b00000010*/0x02、/*7 0b00000001*/0x01、。

  if (!length)
    return shaSuccess;

(長さ)であるなら、shaSuccessを返してください。

  if (!context)
    return shaNull;

(文脈)であるなら、shaNullを返してください。

  if (context->Computed || (length >= 8) || (length == 0)) {
    context->Corrupted = shaStateError;
    return shaStateError;
  }

(文脈->は計算されました| | (長さの>=8)| | (長さ=0))なら文脈、->CorruptedはshaStateErrorと等しいです; リターンshaStateError

  if (context->Corrupted)
     return context->Corrupted;

(文脈、-、>Corrupted) 文脈->にCorruptedを返してください。

  SHA1AddLength(context, length);
  SHA1Finalize(context,
    (uint8_t) ((message_bits & masks[length]) | markbit[length]));

SHA1AddLength(文脈、長さ)。 SHA1Finalize(文脈、(uint8_t)((メッセージ_ビットとマスク[長さ])| markbit[長さ]))。

  return shaSuccess;
}

shaSuccessを返してください。 }

/*
 * SHA1Result
 *
 * Description:
 *   This function will return the 160-bit message digest into the
 *   Message_Digest array provided by the caller.
 *   NOTE: The first octet of hash is stored in the 0th element,
 *      the last octet of hash in the 19th element.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to use to calculate the SHA-1 hash.
 *   Message_Digest: [out]
 *     Where the digest is returned.
 *
 * Returns:
 *   sha Error Code.
 *
 */
int SHA1Result(SHA1Context *context,
    uint8_t Message_Digest[SHA1HashSize])
{
  int i;

/**SHA1Result**記述: * この機能は訪問者によって提供された*メッセージ_Digestアレイに160ビットのメッセージダイジェストを返すでしょう。 * 以下に注意してください。 細切れ肉料理の最初の八重奏は0番目の要素に格納されます、*。19番目の要素における、細切れ肉料理の最後の八重奏。 * * パラメタ: * 文脈: [/アウト] *のSHA-1細切れ肉料理について計算するのに使用する文脈。 * メッセージ_は読みこなします: ダイジェストが返される[out]*。 * * リターン: * sha Error Code。 * */int SHA1Result(SHA1Context*文脈、uint8_t Message_Digest[SHA1HashSize])、int i。

Eastlake 3rd & Hansen        Informational                     [Page 28]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[28ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

  if (!context || !Message_Digest)
    return shaNull;

(Message_Digest| 文脈| )がshaNullを返すなら。

  if (context->Corrupted)
    return context->Corrupted;

(文脈、-、>Corrupted) 文脈->にCorruptedを返してください。

  if (!context->Computed)
    SHA1Finalize(context, 0x80);

(計算された文脈->)SHA1Finalize(文脈、0×80)であるなら。

  for (i = 0; i < SHA1HashSize; ++i)
    Message_Digest[i] = (uint8_t) (context->Intermediate_Hash[i>>2]
              >> 8 * ( 3 - ( i & 0x03 ) ));

(i=0; i<SHA1HashSize; + + i)メッセージ_Digest[i]=(uint8_t)、(文脈、-、>Intermediate_Hash[i>>2]>>8*(3--(iと0×03))。

  return shaSuccess;
}

shaSuccessを返してください。 }

/*
 * SHA1Finalize
 *
 * Description:
 *   This helper function finishes off the digest calculations.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   Pad_Byte: [in]
 *     The last byte to add to the digest before the 0-padding
 *     and length. This will contain the last bits of the message
 *     followed by another single bit. If the message was an
 *     exact multiple of 8-bits long, Pad_Byte will be 0x80.
 *
 * Returns:
 *   sha Error Code.
 *
 */
static void SHA1Finalize(SHA1Context *context, uint8_t Pad_Byte)
{
  int i;
  SHA1PadMessage(context, Pad_Byte);
  /* message may be sensitive, clear it out */
  for (i = 0; i < SHA1_Message_Block_Size; ++i)
    context->Message_Block[i] = 0;
  context->Length_Low = 0;  /* and clear length */
  context->Length_High = 0;
  context->Computed = 1;
}

/**SHA1Finalize**記述: * このヘルパー機能はダイジェスト計算を仕上げます。 * * パラメタ: * 文脈: [コネ/アウト] **をアップデートするSHA文脈は_Byteを水増しします: [in]*、0詰め物*の前にダイジェストに加える最後のバイトと長さ。 これは単一のもう1ビットが支えたメッセージ*の最後のビットを含むでしょう。 長い間メッセージが8ビットの*正確な倍数であったなら、Pad_Byteは0×80になるでしょう。 * * リターン: * sha Error Code。 * */静的な空のSHA1Finalize(SHA1Context*文脈、uint8_t Pad_Byte)int i; SHA1PadMessage(文脈、Pad_Byte); /*メッセージは機密であるかもしれません、それが(i=0; i<SHA1_Message_Block_Size; + + i)文脈->Message_Block[i]のための*/から0;文脈と等しいのが明確です。-0; /*と明確な長さの文脈*/>Length_High=0;文脈->>Length_Low=Computedは1と等しいです。

/*

/*

Eastlake 3rd & Hansen        Informational                     [Page 29]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[29ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 * SHA1PadMessage
 *
 * Description:
 *   According to the standard, the message must be padded to an
 *   even 512 bits. The first padding bit must be a '1'. The last
 *   64 bits represent the length of the original message. All bits
 *   in between should be 0. This helper function will pad the
 *   message according to those rules by filling the Message_Block
 *   array accordingly. When it returns, it can be assumed that the
 *   message digest has been computed.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to pad
 *   Pad_Byte: [in]
 *     The last byte to add to the digest before the 0-padding
 *     and length. This will contain the last bits of the message
 *     followed by another single bit. If the message was an
 *     exact multiple of 8-bits long, Pad_Byte will be 0x80.
 *
 * Returns:
 *   Nothing.
 */
static void SHA1PadMessage(SHA1Context *context, uint8_t Pad_Byte)
{
  /*
   * Check to see if the current message block is too small to hold
   * the initial padding bits and length. If so, we will pad the
   * block, process it, and then continue padding into a second
   * block.
   */
  if (context->Message_Block_Index >= (SHA1_Message_Block_Size - 8)) {
    context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
    while (context->Message_Block_Index < SHA1_Message_Block_Size)
      context->Message_Block[context->Message_Block_Index++] = 0;

* SHA1PadMessage**記述: * 規格によると、*にメッセージを512ビットさえ水増ししなければなりません。 最初の詰め物ビットは'1'であるに違いありません。 最終*64ビットはオリジナルのメッセージの長さを表します。 *すべてのビット、0が中間であるべきです。 それらの規則に従って、このヘルパー機能は、それに従って、Message_Block*アレイをいっぱいにすることによって、*メッセージを水増しするでしょう。 戻るとき、*メッセージダイジェストを計算してあると思うことができます。 * * パラメタ: * 文脈: [コネ/アウト] **を水増しする文脈は_Byteを水増しします: [in]*、0詰め物*の前にダイジェストに加える最後のバイトと長さ。 これは単一のもう1ビットが支えたメッセージ*の最後のビットを含むでしょう。 長い間メッセージが8ビットの*正確な倍数であったなら、Pad_Byteは0×80になるでしょう。 * * リターン: * 何でもない。 *現在のメッセージであるなら、ブロックは*が初期の詰め物ビットと長さであることを保持できないくらいわずかです。/静的な空のSHA1PadMessage(SHA1Context*文脈、uint8_t Pad_Byte)、そうだとすれば、私たちが、aの2*番目のブロック*/に*ブロックを水増しして、それを処理して、次に、そっと歩き続けるつもりであるのを確実にする/**チェック、(文脈、-、>Message_Block_Index>=(SHA1_Message_Block_Size--8)、文脈、-、Message_Block_Index++=が水増しする>Message_Blockcontext->、_Byte; (文脈->は_ブロック_インデックス<SHA1_メッセージ_ブロック_サイズを通信させます)文脈->メッセージ_Blockcontext->である間、_ブロック_インデックス++=0を通信させてください。

    SHA1ProcessMessageBlock(context);
  } else
    context->Message_Block[context->Message_Block_Index++] = Pad_Byte;

SHA1ProcessMessageBlock(文脈)。 ほかの文脈、-、>Message_Block、[文脈、->Message_Block_Index++] =は_Byteを水増しします。

  while (context->Message_Block_Index < (SHA1_Message_Block_Size - 8))
    context->Message_Block[context->Message_Block_Index++] = 0;

(文脈->は_ブロック_インデックス<(SHA1_メッセージ_ブロック_サイズ--8)を通信させます)文脈->メッセージ_ブロック[文脈->は_ブロック_インデックス++を通信させる]=0をゆったり過ごしてください。

  /*
   * Store the message length as the last 8 octets
   */
  context->Message_Block[56] = (uint8_t) (context->Length_High >> 24);
  context->Message_Block[57] = (uint8_t) (context->Length_High >> 16);

ベスト8八重奏文脈*/>Message_Block[56]が(uint8_t)と等しいときに/**がメッセージ長を格納する、(文脈、-、>Length_High>>24)。 文脈->が_ブロック[57]=(uint8_t)を通信させる、(文脈、-、>長さ_の高い>>16)。

Eastlake 3rd & Hansen        Informational                     [Page 30]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[30ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

  context->Message_Block[58] = (uint8_t) (context->Length_High >> 8);
  context->Message_Block[59] = (uint8_t) (context->Length_High);
  context->Message_Block[60] = (uint8_t) (context->Length_Low >> 24);
  context->Message_Block[61] = (uint8_t) (context->Length_Low >> 16);
  context->Message_Block[62] = (uint8_t) (context->Length_Low >> 8);
  context->Message_Block[63] = (uint8_t) (context->Length_Low);

文脈->が_ブロック[58]=(uint8_t)を通信させる、(文脈、-、>長さ_の高い>>8)。 文脈->が_ブロック[59]=(uint8_t)を通信させる、(文脈、-、>長さ_高値)、。 文脈->が_ブロック[60]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>24)。 文脈->が_ブロック[61]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>16)。 文脈->が_ブロック[62]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>8)。 文脈->が_ブロック[63]=(uint8_t)を通信させる、(文脈、-、>長さ_安値)、。

  SHA1ProcessMessageBlock(context);
}

SHA1ProcessMessageBlock(文脈)。 }

/*
 * SHA1ProcessMessageBlock
 *
 * Description:
 *   This helper function will process the next 512 bits of the
 *   message stored in the Message_Block array.
 *
 * Parameters:
 *   None.
 *
 * Returns:
 *   Nothing.
 *
 * Comments:
 *   Many of the variable names in this code, especially the
 *   single character names, were used because those were the
 *   names used in the publication.
 */
static void SHA1ProcessMessageBlock(SHA1Context *context)
{
  /* Constants defined in FIPS-180-2, section 4.2.1 */
  const uint32_t K[4] = {
      0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6
  };
  int        t;               /* Loop counter */
  uint32_t   temp;            /* Temporary word value */
  uint32_t   W[80];           /* Word sequence */
  uint32_t   A, B, C, D, E;   /* Word buffers */

/* * SHA1ProcessMessageBlock * * Description: * This helper function will process the next 512 bits of the * message stored in the Message_Block array. * * Parameters: * None. * * Returns: * Nothing. * * Comments: * Many of the variable names in this code, especially the * single character names, were used because those were the * names used in the publication. */ static void SHA1ProcessMessageBlock(SHA1Context *context) { /* Constants defined in FIPS-180-2, section 4.2.1 */ const uint32_t K[4] = { 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6 }; int t; /* Loop counter */ uint32_t temp; /* Temporary word value */ uint32_t W[80]; /* Word sequence */ uint32_t A, B, C, D, E; /* Word buffers */

  /*
   * Initialize the first 16 words in the array W
   */
  for (t = 0; t < 16; t++) {
    W[t]  = ((uint32_t)context->Message_Block[t * 4]) << 24;
    W[t] |= ((uint32_t)context->Message_Block[t * 4 + 1]) << 16;
    W[t] |= ((uint32_t)context->Message_Block[t * 4 + 2]) << 8;
    W[t] |= ((uint32_t)context->Message_Block[t * 4 + 3]);
  }

/* * Initialize the first 16 words in the array W */ for (t = 0; t < 16; t++) { W[t] = ((uint32_t)context->Message_Block[t * 4]) << 24; W[t] |= ((uint32_t)context->Message_Block[t * 4 + 1]) << 16; W[t] |= ((uint32_t)context->Message_Block[t * 4 + 2]) << 8; W[t] |= ((uint32_t)context->Message_Block[t * 4 + 3]); }

Eastlake 3rd & Hansen        Informational                     [Page 31]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 31] RFC 4634 SHAs and HMAC-SHAs July 2006

  for (t = 16; t < 80; t++)
    W[t] = SHA1_ROTL(1, W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);

for (t = 16; t < 80; t++) W[t] = SHA1_ROTL(1, W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);

  A = context->Intermediate_Hash[0];
  B = context->Intermediate_Hash[1];
  C = context->Intermediate_Hash[2];
  D = context->Intermediate_Hash[3];
  E = context->Intermediate_Hash[4];

A = context->Intermediate_Hash[0]; B = context->Intermediate_Hash[1]; C = context->Intermediate_Hash[2]; D = context->Intermediate_Hash[3]; E = context->Intermediate_Hash[4];

  for (t = 0; t < 20; t++) {
    temp = SHA1_ROTL(5,A) + SHA_Ch(B, C, D) + E + W[t] + K[0];
    E = D;
    D = C;
    C = SHA1_ROTL(30,B);
    B = A;
    A = temp;
  }

for (t = 0; t < 20; t++) { temp = SHA1_ROTL(5,A) + SHA_Ch(B, C, D) + E + W[t] + K[0]; E = D; D = C; C = SHA1_ROTL(30,B); B = A; A = temp; }

  for (t = 20; t < 40; t++) {
    temp = SHA1_ROTL(5,A) + SHA_Parity(B, C, D) + E + W[t] + K[1];
    E = D;
    D = C;
    C = SHA1_ROTL(30,B);
    B = A;
    A = temp;
  }

for (t = 20; t < 40; t++) { temp = SHA1_ROTL(5,A) + SHA_Parity(B, C, D) + E + W[t] + K[1]; E = D; D = C; C = SHA1_ROTL(30,B); B = A; A = temp; }

  for (t = 40; t < 60; t++) {
    temp = SHA1_ROTL(5,A) + SHA_Maj(B, C, D) + E + W[t] + K[2];
    E = D;
    D = C;
    C = SHA1_ROTL(30,B);
    B = A;
    A = temp;
  }

for (t = 40; t < 60; t++) { temp = SHA1_ROTL(5,A) + SHA_Maj(B, C, D) + E + W[t] + K[2]; E = D; D = C; C = SHA1_ROTL(30,B); B = A; A = temp; }

  for (t = 60; t < 80; t++) {
    temp = SHA1_ROTL(5,A) + SHA_Parity(B, C, D) + E + W[t] + K[3];
    E = D;
    D = C;
    C = SHA1_ROTL(30,B);
    B = A;
    A = temp;
  }

for (t = 60; t < 80; t++) { temp = SHA1_ROTL(5,A) + SHA_Parity(B, C, D) + E + W[t] + K[3]; E = D; D = C; C = SHA1_ROTL(30,B); B = A; A = temp; }

  context->Intermediate_Hash[0] += A;
  context->Intermediate_Hash[1] += B;
  context->Intermediate_Hash[2] += C;

context->Intermediate_Hash[0] += A; context->Intermediate_Hash[1] += B; context->Intermediate_Hash[2] += C;

Eastlake 3rd & Hansen        Informational                     [Page 32]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 32] RFC 4634 SHAs and HMAC-SHAs July 2006

  context->Intermediate_Hash[3] += D;
  context->Intermediate_Hash[4] += E;

context->Intermediate_Hash[3] += D; context->Intermediate_Hash[4] += E;

  context->Message_Block_Index = 0;
}

context->Message_Block_Index = 0; }

8.2.2.  sha224-256.c

8.2.2. sha224-256.c

/*************************** sha224-256.c ***************************/
/********************* See RFC 4634 for details *********************/
/*
 * Description:
 *   This file implements the Secure Hash Signature Standard
 *   algorithms as defined in the National Institute of Standards
 *   and Technology Federal Information Processing Standards
 *   Publication (FIPS PUB) 180-1 published on April 17, 1995, 180-2
 *   published on August 1, 2002, and the FIPS PUB 180-2 Change
 *   Notice published on February 28, 2004.
 *
 *   A combined document showing all algorithms is available at
 *       http://csrc.nist.gov/publications/fips/
 *       fips180-2/fips180-2withchangenotice.pdf
 *
 *   The SHA-224 and SHA-256 algorithms produce 224-bit and 256-bit
 *   message digests for a given data stream. It should take about
 *   2**n steps to find a message with the same digest as a given
 *   message and 2**(n/2) to find any two messages with the same
 *   digest, when n is the digest size in bits. Therefore, this
 *   algorithm can serve as a means of providing a
 *   "fingerprint" for a message.
 *
 * Portability Issues:
 *   SHA-224 and SHA-256 are defined in terms of 32-bit "words".
 *   This code uses <stdint.h> (included via "sha.h") to define 32
 *   and 8 bit unsigned integer types. If your C compiler does not
 *   support 32 bit unsigned integers, this code is not
 *   appropriate.
 *
 * Caveats:
 *   SHA-224 and SHA-256 are designed to work with messages less
 *   than 2^64 bits long. This implementation uses SHA224/256Input()
 *   to hash the bits that are a multiple of the size of an 8-bit
 *   character, and then uses SHA224/256FinalBits() to hash the
 *   final few bits of the input.
 */

/*************************** sha224-256.c ***************************/ /********************* See RFC 4634 for details *********************/ /* * Description: * This file implements the Secure Hash Signature Standard * algorithms as defined in the National Institute of Standards * and Technology Federal Information Processing Standards * Publication (FIPS PUB) 180-1 published on April 17, 1995, 180-2 * published on August 1, 2002, and the FIPS PUB 180-2 Change * Notice published on February 28, 2004. * * A combined document showing all algorithms is available at * http://csrc.nist.gov/publications/fips/ * fips180-2/fips180-2withchangenotice.pdf * * The SHA-224 and SHA-256 algorithms produce 224-bit and 256-bit * message digests for a given data stream. It should take about * 2**n steps to find a message with the same digest as a given * message and 2**(n/2) to find any two messages with the same * digest, when n is the digest size in bits. Therefore, this * algorithm can serve as a means of providing a * "fingerprint" for a message. * * Portability Issues: * SHA-224 and SHA-256 are defined in terms of 32-bit "words". * This code uses <stdint.h> (included via "sha.h") to define 32 * and 8 bit unsigned integer types. If your C compiler does not * support 32 bit unsigned integers, this code is not * appropriate. * * Caveats: * SHA-224 and SHA-256 are designed to work with messages less * than 2^64 bits long. This implementation uses SHA224/256Input() * to hash the bits that are a multiple of the size of an 8-bit * character, and then uses SHA224/256FinalBits() to hash the * final few bits of the input. */

#include "sha.h"
#include "sha-private.h"

#include "sha.h" #include "sha-private.h"

Eastlake 3rd & Hansen        Informational                     [Page 33]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 33] RFC 4634 SHAs and HMAC-SHAs July 2006

/* Define the SHA shift, rotate left and rotate right macro */
#define SHA256_SHR(bits,word)      ((word) >> (bits))
#define SHA256_ROTL(bits,word)                         \
  (((word) << (bits)) | ((word) >> (32-(bits))))
#define SHA256_ROTR(bits,word)                         \
  (((word) >> (bits)) | ((word) << (32-(bits))))

/* Define the SHA shift, rotate left and rotate right macro */ #define SHA256_SHR(bits,word) ((word) >> (bits)) #define SHA256_ROTL(bits,word) \ (((word) << (bits)) | ((word) >> (32-(bits)))) #define SHA256_ROTR(bits,word) \ (((word) >> (bits)) | ((word) << (32-(bits))))

/* Define the SHA SIGMA and sigma macros */
#define SHA256_SIGMA0(word)   \
  (SHA256_ROTR( 2,word) ^ SHA256_ROTR(13,word) ^ SHA256_ROTR(22,word))
#define SHA256_SIGMA1(word)   \
  (SHA256_ROTR( 6,word) ^ SHA256_ROTR(11,word) ^ SHA256_ROTR(25,word))
#define SHA256_sigma0(word)   \
  (SHA256_ROTR( 7,word) ^ SHA256_ROTR(18,word) ^ SHA256_SHR( 3,word))
#define SHA256_sigma1(word)   \
  (SHA256_ROTR(17,word) ^ SHA256_ROTR(19,word) ^ SHA256_SHR(10,word))

/* Define the SHA SIGMA and sigma macros */ #define SHA256_SIGMA0(word) \ (SHA256_ROTR( 2,word) ^ SHA256_ROTR(13,word) ^ SHA256_ROTR(22,word)) #define SHA256_SIGMA1(word) \ (SHA256_ROTR( 6,word) ^ SHA256_ROTR(11,word) ^ SHA256_ROTR(25,word)) #define SHA256_sigma0(word) \ (SHA256_ROTR( 7,word) ^ SHA256_ROTR(18,word) ^ SHA256_SHR( 3,word)) #define SHA256_sigma1(word) \ (SHA256_ROTR(17,word) ^ SHA256_ROTR(19,word) ^ SHA256_SHR(10,word))

/*
 * add "length" to the length
 */
static uint32_t addTemp;
#define SHA224_256AddLength(context, length)               \
  (addTemp = (context)->Length_Low, (context)->Corrupted = \
    (((context)->Length_Low += (length)) < addTemp) &&     \
    (++(context)->Length_High == 0) ? 1 : 0)

/* * add "length" to the length */ static uint32_t addTemp; #define SHA224_256AddLength(context, length) \ (addTemp = (context)->Length_Low, (context)->Corrupted = \ (((context)->Length_Low += (length)) < addTemp) && \ (++(context)->Length_High == 0) ? 1 : 0)

/* Local Function Prototypes */
static void SHA224_256Finalize(SHA256Context *context,
  uint8_t Pad_Byte);
static void SHA224_256PadMessage(SHA256Context *context,
  uint8_t Pad_Byte);
static void SHA224_256ProcessMessageBlock(SHA256Context *context);
static int SHA224_256Reset(SHA256Context *context, uint32_t *H0);
static int SHA224_256ResultN(SHA256Context *context,
  uint8_t Message_Digest[], int HashSize);

/* Local Function Prototypes */ static void SHA224_256Finalize(SHA256Context *context, uint8_t Pad_Byte); static void SHA224_256PadMessage(SHA256Context *context, uint8_t Pad_Byte); static void SHA224_256ProcessMessageBlock(SHA256Context *context); static int SHA224_256Reset(SHA256Context *context, uint32_t *H0); static int SHA224_256ResultN(SHA256Context *context, uint8_t Message_Digest[], int HashSize);

/* Initial Hash Values: FIPS-180-2 Change Notice 1 */
static uint32_t SHA224_H0[SHA256HashSize/4] = {
    0xC1059ED8, 0x367CD507, 0x3070DD17, 0xF70E5939,
    0xFFC00B31, 0x68581511, 0x64F98FA7, 0xBEFA4FA4
};

/* Initial Hash Values: FIPS-180-2 Change Notice 1 */ static uint32_t SHA224_H0[SHA256HashSize/4] = { 0xC1059ED8, 0x367CD507, 0x3070DD17, 0xF70E5939, 0xFFC00B31, 0x68581511, 0x64F98FA7, 0xBEFA4FA4 };

/* Initial Hash Values: FIPS-180-2 section 5.3.2 */
static uint32_t SHA256_H0[SHA256HashSize/4] = {
  0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
  0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
};

/* Initial Hash Values: FIPS-180-2 section 5.3.2 */ static uint32_t SHA256_H0[SHA256HashSize/4] = { 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19 };

Eastlake 3rd & Hansen        Informational                     [Page 34]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 34] RFC 4634 SHAs and HMAC-SHAs July 2006

/*
 * SHA224Reset
 *
 * Description:
 *   This function will initialize the SHA384Context in preparation
 *   for computing a new SHA224 message digest.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to reset.
 *
 * Returns:
 *   sha Error Code.
 */
int SHA224Reset(SHA224Context *context)
{
  return SHA224_256Reset(context, SHA224_H0);
}

/* * SHA224Reset * * Description: * This function will initialize the SHA384Context in preparation * for computing a new SHA224 message digest. * * Parameters: * context: [in/out] * The context to reset. * * Returns: * sha Error Code. */ int SHA224Reset(SHA224Context *context) { return SHA224_256Reset(context, SHA224_H0); }

/*
 * SHA224Input
 *
 * Description:
 *   This function accepts an array of octets as the next portion
 *   of the message.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   message_array: [in]
 *     An array of characters representing the next portion of
 *     the message.
 *   length: [in]
 *     The length of the message in message_array
 *
 * Returns:
 *   sha Error Code.
 *
 */
int SHA224Input(SHA224Context *context, const uint8_t *message_array,
    unsigned int length)
{
  return SHA256Input(context, message_array, length);
}

/* * SHA224Input * * Description: * This function accepts an array of octets as the next portion * of the message. * * Parameters: * context: [in/out] * The SHA context to update * message_array: [in] * An array of characters representing the next portion of * the message. * length: [in] * The length of the message in message_array * * Returns: * sha Error Code. * */ int SHA224Input(SHA224Context *context, const uint8_t *message_array, unsigned int length) { return SHA256Input(context, message_array, length); }

/*
 * SHA224FinalBits
 *

/* * SHA224FinalBits *

Eastlake 3rd & Hansen        Informational                     [Page 35]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 35] RFC 4634 SHAs and HMAC-SHAs July 2006

 * Description:
 *   This function will add in any final bits of the message.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   message_bits: [in]
 *     The final bits of the message, in the upper portion of the
 *     byte. (Use 0b###00000 instead of 0b00000### to input the
 *     three bits ###.)
 *   length: [in]
 *     The number of bits in message_bits, between 1 and 7.
 *
 * Returns:
 *   sha Error Code.
 */
int SHA224FinalBits( SHA224Context *context,
    const uint8_t message_bits, unsigned int length)
{
  return SHA256FinalBits(context, message_bits, length);
}

* Description: * This function will add in any final bits of the message. * * Parameters: * context: [in/out] * The SHA context to update * message_bits: [in] * The final bits of the message, in the upper portion of the * byte. (Use 0b###00000 instead of 0b00000### to input the * three bits ###.) * length: [in] * The number of bits in message_bits, between 1 and 7. * * Returns: * sha Error Code. */ int SHA224FinalBits( SHA224Context *context, const uint8_t message_bits, unsigned int length) { return SHA256FinalBits(context, message_bits, length); }

/*
 * SHA224Result
 *
 * Description:
 *   This function will return the 224-bit message
 *   digest into the Message_Digest array provided by the caller.
 *   NOTE: The first octet of hash is stored in the 0th element,
 *      the last octet of hash in the 28th element.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to use to calculate the SHA hash.
 *   Message_Digest: [out]
 *     Where the digest is returned.
 *
 * Returns:
 *   sha Error Code.
 */
int SHA224Result(SHA224Context *context,
    uint8_t Message_Digest[SHA224HashSize])
{
  return SHA224_256ResultN(context, Message_Digest, SHA224HashSize);
}

/* * SHA224Result * * Description: * This function will return the 224-bit message * digest into the Message_Digest array provided by the caller. * NOTE: The first octet of hash is stored in the 0th element, * the last octet of hash in the 28th element. * * Parameters: * context: [in/out] * The context to use to calculate the SHA hash. * Message_Digest: [out] * Where the digest is returned. * * Returns: * sha Error Code. */ int SHA224Result(SHA224Context *context, uint8_t Message_Digest[SHA224HashSize]) { return SHA224_256ResultN(context, Message_Digest, SHA224HashSize); }

/*
 * SHA256Reset

/* * SHA256Reset

Eastlake 3rd & Hansen        Informational                     [Page 36]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 36] RFC 4634 SHAs and HMAC-SHAs July 2006

 *
 * Description:
 *   This function will initialize the SHA256Context in preparation
 *   for computing a new SHA256 message digest.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to reset.
 *
 * Returns:
 *   sha Error Code.
 */
int SHA256Reset(SHA256Context *context)
{
  return SHA224_256Reset(context, SHA256_H0);
}

* * Description: * This function will initialize the SHA256Context in preparation * for computing a new SHA256 message digest. * * Parameters: * context: [in/out] * The context to reset. * * Returns: * sha Error Code. */ int SHA256Reset(SHA256Context *context) { return SHA224_256Reset(context, SHA256_H0); }

/*
 * SHA256Input
 *
 * Description:
 *   This function accepts an array of octets as the next portion
 *   of the message.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   message_array: [in]
 *     An array of characters representing the next portion of
 *     the message.
 *   length: [in]
 *     The length of the message in message_array
 *
 * Returns:
 *   sha Error Code.
 */
int SHA256Input(SHA256Context *context, const uint8_t *message_array,
    unsigned int length)
{
  if (!length)
    return shaSuccess;

/* * SHA256Input * * Description: * This function accepts an array of octets as the next portion * of the message. * * Parameters: * context: [in/out] * The SHA context to update * message_array: [in] * An array of characters representing the next portion of * the message. * length: [in] * The length of the message in message_array * * Returns: * sha Error Code. */ int SHA256Input(SHA256Context *context, const uint8_t *message_array, unsigned int length) { if (!length) return shaSuccess;

  if (!context || !message_array)
    return shaNull;

if (!context || !message_array) return shaNull;

  if (context->Computed) {
    context->Corrupted = shaStateError;
    return shaStateError;

if (context->Computed) { context->Corrupted = shaStateError; return shaStateError;

Eastlake 3rd & Hansen        Informational                     [Page 37]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 37] RFC 4634 SHAs and HMAC-SHAs July 2006

  }

}

  if (context->Corrupted)
     return context->Corrupted;

if (context->Corrupted) return context->Corrupted;

  while (length-- && !context->Corrupted) {
    context->Message_Block[context->Message_Block_Index++] =
            (*message_array & 0xFF);

while (length-- && !context->Corrupted) { context->Message_Block[context->Message_Block_Index++] = (*message_array & 0xFF);

    if (!SHA224_256AddLength(context, 8) &&
      (context->Message_Block_Index == SHA256_Message_Block_Size))
      SHA224_256ProcessMessageBlock(context);

if (!SHA224_256AddLength(context, 8) && (context->Message_Block_Index == SHA256_Message_Block_Size)) SHA224_256ProcessMessageBlock(context);

    message_array++;
  }

message_array++; }

  return shaSuccess;

return shaSuccess;

}

}

/*
 * SHA256FinalBits
 *
 * Description:
 *   This function will add in any final bits of the message.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   message_bits: [in]
 *     The final bits of the message, in the upper portion of the
 *     byte. (Use 0b###00000 instead of 0b00000### to input the
 *     three bits ###.)
 *   length: [in]
 *     The number of bits in message_bits, between 1 and 7.
 *
 * Returns:
 *   sha Error Code.
 */
int SHA256FinalBits(SHA256Context *context,
    const uint8_t message_bits, unsigned int length)
{
  uint8_t masks[8] = {
      /* 0 0b00000000 */ 0x00, /* 1 0b10000000 */ 0x80,
      /* 2 0b11000000 */ 0xC0, /* 3 0b11100000 */ 0xE0,
      /* 4 0b11110000 */ 0xF0, /* 5 0b11111000 */ 0xF8,
      /* 6 0b11111100 */ 0xFC, /* 7 0b11111110 */ 0xFE
  };

/* * SHA256FinalBits * * Description: * This function will add in any final bits of the message. * * Parameters: * context: [in/out] * The SHA context to update * message_bits: [in] * The final bits of the message, in the upper portion of the * byte. (Use 0b###00000 instead of 0b00000### to input the * three bits ###.) * length: [in] * The number of bits in message_bits, between 1 and 7. * * Returns: * sha Error Code. */ int SHA256FinalBits(SHA256Context *context, const uint8_t message_bits, unsigned int length) { uint8_t masks[8] = { /* 0 0b00000000 */ 0x00, /* 1 0b10000000 */ 0x80, /* 2 0b11000000 */ 0xC0, /* 3 0b11100000 */ 0xE0, /* 4 0b11110000 */ 0xF0, /* 5 0b11111000 */ 0xF8, /* 6 0b11111100 */ 0xFC, /* 7 0b11111110 */ 0xFE };

Eastlake 3rd & Hansen        Informational                     [Page 38]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 38] RFC 4634 SHAs and HMAC-SHAs July 2006

  uint8_t markbit[8] = {
      /* 0 0b10000000 */ 0x80, /* 1 0b01000000 */ 0x40,
      /* 2 0b00100000 */ 0x20, /* 3 0b00010000 */ 0x10,
      /* 4 0b00001000 */ 0x08, /* 5 0b00000100 */ 0x04,
      /* 6 0b00000010 */ 0x02, /* 7 0b00000001 */ 0x01
  };

uint8_t markbit[8] = { /* 0 0b10000000 */ 0x80, /* 1 0b01000000 */ 0x40, /* 2 0b00100000 */ 0x20, /* 3 0b00010000 */ 0x10, /* 4 0b00001000 */ 0x08, /* 5 0b00000100 */ 0x04, /* 6 0b00000010 */ 0x02, /* 7 0b00000001 */ 0x01 };

  if (!length)
    return shaSuccess;

if (!length) return shaSuccess;

  if (!context)
    return shaNull;

if (!context) return shaNull;

  if ((context->Computed) || (length >= 8) || (length == 0)) {
    context->Corrupted = shaStateError;
    return shaStateError;
  }

if ((context->Computed) || (length >= 8) || (length == 0)) { context->Corrupted = shaStateError; return shaStateError; }

  if (context->Corrupted)
    return context->Corrupted;

if (context->Corrupted) return context->Corrupted;

  SHA224_256AddLength(context, length);
  SHA224_256Finalize(context, (uint8_t)
    ((message_bits & masks[length]) | markbit[length]));

SHA224_256AddLength(context, length); SHA224_256Finalize(context, (uint8_t) ((message_bits & masks[length]) | markbit[length]));

  return shaSuccess;
}

return shaSuccess; }

/*
 * SHA256Result
 *
 * Description:
 *   This function will return the 256-bit message
 *   digest into the Message_Digest array provided by the caller.
 *   NOTE: The first octet of hash is stored in the 0th element,
 *      the last octet of hash in the 32nd element.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to use to calculate the SHA hash.
 *   Message_Digest: [out]
 *     Where the digest is returned.
 *
 * Returns:
 *   sha Error Code.
 */
int SHA256Result(SHA256Context *context, uint8_t Message_Digest[])
{

/* * SHA256Result * * Description: * This function will return the 256-bit message * digest into the Message_Digest array provided by the caller. * NOTE: The first octet of hash is stored in the 0th element, * the last octet of hash in the 32nd element. * * Parameters: * context: [in/out] * The context to use to calculate the SHA hash. * Message_Digest: [out] * Where the digest is returned. * * Returns: * sha Error Code. */ int SHA256Result(SHA256Context *context, uint8_t Message_Digest[]) {

Eastlake 3rd & Hansen        Informational                     [Page 39]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 39] RFC 4634 SHAs and HMAC-SHAs July 2006

  return SHA224_256ResultN(context, Message_Digest, SHA256HashSize);
}

return SHA224_256ResultN(context, Message_Digest, SHA256HashSize); }

/*
 * SHA224_256Finalize
 *
 * Description:
 *   This helper function finishes off the digest calculations.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   Pad_Byte: [in]
 *     The last byte to add to the digest before the 0-padding
 *     and length. This will contain the last bits of the message
 *     followed by another single bit. If the message was an
 *     exact multiple of 8-bits long, Pad_Byte will be 0x80.
 *
 * Returns:
 *   sha Error Code.
 */
static void SHA224_256Finalize(SHA256Context *context,
    uint8_t Pad_Byte)
{
  int i;
  SHA224_256PadMessage(context, Pad_Byte);
  /* message may be sensitive, so clear it out */
  for (i = 0; i < SHA256_Message_Block_Size; ++i)
    context->Message_Block[i] = 0;
  context->Length_Low = 0;  /* and clear length */
  context->Length_High = 0;
  context->Computed = 1;
}

/* * SHA224_256Finalize * * Description: * This helper function finishes off the digest calculations. * * Parameters: * context: [in/out] * The SHA context to update * Pad_Byte: [in] * The last byte to add to the digest before the 0-padding * and length. This will contain the last bits of the message * followed by another single bit. If the message was an * exact multiple of 8-bits long, Pad_Byte will be 0x80. * * Returns: * sha Error Code. */ static void SHA224_256Finalize(SHA256Context *context, uint8_t Pad_Byte) { int i; SHA224_256PadMessage(context, Pad_Byte); /* message may be sensitive, so clear it out */ for (i = 0; i < SHA256_Message_Block_Size; ++i) context->Message_Block[i] = 0; context->Length_Low = 0; /* and clear length */ context->Length_High = 0; context->Computed = 1; }

/*
 * SHA224_256PadMessage
 *
 * Description:
 *   According to the standard, the message must be padded to an
 *   even 512 bits. The first padding bit must be a '1'. The
 *   last 64 bits represent the length of the original message.
 *   All bits in between should be 0. This helper function will pad
 *   the message according to those rules by filling the
 *   Message_Block array accordingly. When it returns, it can be
 *   assumed that the message digest has been computed.
 *
 * Parameters:
 *   context: [in/out]

/* * SHA224_256PadMessage * * Description: * According to the standard, the message must be padded to an * even 512 bits. The first padding bit must be a '1'. The * last 64 bits represent the length of the original message. * All bits in between should be 0. This helper function will pad * the message according to those rules by filling the * Message_Block array accordingly. When it returns, it can be * assumed that the message digest has been computed. * * Parameters: * context: [in/out]

Eastlake 3rd & Hansen        Informational                     [Page 40]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[40ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 *     The context to pad
 *   Pad_Byte: [in]
 *     The last byte to add to the digest before the 0-padding
 *     and length. This will contain the last bits of the message
 *     followed by another single bit. If the message was an
 *     exact multiple of 8-bits long, Pad_Byte will be 0x80.
 *
 * Returns:
 *   Nothing.
 */
static void SHA224_256PadMessage(SHA256Context *context,
    uint8_t Pad_Byte)
{
  /*
   * Check to see if the current message block is too small to hold
   * the initial padding bits and length. If so, we will pad the
   * block, process it, and then continue padding into a second
   * block.
   */
  if (context->Message_Block_Index >= (SHA256_Message_Block_Size-8)) {
    context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
    while (context->Message_Block_Index < SHA256_Message_Block_Size)
      context->Message_Block[context->Message_Block_Index++] = 0;
    SHA224_256ProcessMessageBlock(context);
  } else
    context->Message_Block[context->Message_Block_Index++] = Pad_Byte;

* *パッド_Byteを水増しする文脈: [in]*、0詰め物*の前にダイジェストに加える最後のバイトと長さ。 これは単一のもう1ビットが支えたメッセージ*の最後のビットを含むでしょう。 長い間メッセージが8ビットの*正確な倍数であったなら、Pad_Byteは0×80になるでしょう。 * * リターン: * 何でもない。 *電流であるならブロックを通信させるように確実にする/**チェックは*が初期の詰め物ビットと長さであることを保持できないくらい小さいです。/静的な空のSHA224_256PadMessage(SHA256Context*文脈、uint8_t Pad_Byte)、そうだとすれば、私たちは、2*番目のブロックに*ブロックを水増しして、それを処理して、次に、そっと歩き続けるつもりです; */、(文脈、->Message_Block_Index>が(SHA256_Message_Block_Size-8)と等しい、文脈、-、Message_Block_Index++=が水増しする>Message_Blockcontext->、_Byte;、(文脈、-、>Message_Block_Index<SHA256_Message_Block_Size) 文脈->、Message_Blockcontext、->Message_Block_Index++は0と等しいです; SHA224_256ProcessMessageBlock(文脈)、ほかの文脈、-、Message_Block_Index++=が水増しする>Message_Blockcontext->、_Byte。

  while (context->Message_Block_Index < (SHA256_Message_Block_Size-8))
    context->Message_Block[context->Message_Block_Index++] = 0;

(文脈->は_ブロック_インデックス<(SHA256_メッセージ_ブロック_サイズ-8)を通信させます)文脈->メッセージ_ブロック[文脈->は_ブロック_インデックス++を通信させる]=0をゆったり過ごしてください。

  /*
   * Store the message length as the last 8 octets
   */
  context->Message_Block[56] = (uint8_t)(context->Length_High >> 24);
  context->Message_Block[57] = (uint8_t)(context->Length_High >> 16);
  context->Message_Block[58] = (uint8_t)(context->Length_High >> 8);
  context->Message_Block[59] = (uint8_t)(context->Length_High);
  context->Message_Block[60] = (uint8_t)(context->Length_Low >> 24);
  context->Message_Block[61] = (uint8_t)(context->Length_Low >> 16);
  context->Message_Block[62] = (uint8_t)(context->Length_Low >> 8);
  context->Message_Block[63] = (uint8_t)(context->Length_Low);

ベスト8八重奏文脈*/>Message_Block[56]が(uint8_t)と等しいときに/**がメッセージ長を格納する、(文脈、-、>Length_High>>24)。 文脈->が_ブロック[57]=(uint8_t)を通信させる、(文脈、-、>長さ_の高い>>16)。 文脈->が_ブロック[58]=(uint8_t)を通信させる、(文脈、-、>長さ_の高い>>8)。 文脈->が_ブロック[59]=(uint8_t)を通信させる、(文脈、-、>長さ_高値)、。 文脈->が_ブロック[60]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>24)。 文脈->が_ブロック[61]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>16)。 文脈->が_ブロック[62]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>8)。 文脈->が_ブロック[63]=(uint8_t)を通信させる、(文脈、-、>長さ_安値)、。

  SHA224_256ProcessMessageBlock(context);
}

SHA224_256ProcessMessageBlock(文脈)。 }

/*
 * SHA224_256ProcessMessageBlock
 *

/**SHA224_256ProcessMessageBlock*

Eastlake 3rd & Hansen        Informational                     [Page 41]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[41ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 * Description:
 *   This function will process the next 512 bits of the message
 *   stored in the Message_Block array.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *
 * Returns:
 *   Nothing.
 *
 * Comments:
 *   Many of the variable names in this code, especially the
 *   single character names, were used because those were the
 *   names used in the publication.
 */
static void SHA224_256ProcessMessageBlock(SHA256Context *context)
{
  /* Constants defined in FIPS-180-2, section 4.2.2 */
  static const uint32_t K[64] = {
      0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,
      0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,
      0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,
      0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
      0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,
      0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
      0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
      0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
      0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
      0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,
      0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,
      0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
      0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
  };
  int        t, t4;                   /* Loop counter */
  uint32_t   temp1, temp2;            /* Temporary word value */
  uint32_t   W[64];                   /* Word sequence */
  uint32_t   A, B, C, D, E, F, G, H;  /* Word buffers */

* 記述: * この機能はMessage_Blockアレイに格納されたメッセージ*の次の512ビットを処理するでしょう。 * * パラメタ: * 文脈: [コネ/アウト] ***をアップデートするSHA文脈は戻ります: * 何でもない。 * * コメント: * それらが公表で使用される*名であったので、このコードの変数名の多く(特に*ただ一つのキャラクタ名)が使用されました。 */静的な空のSHA224_256ProcessMessageBlock(SHA256Context*文脈)、/*定数は中でFIPS-180-2、セクション4.2を定義しました; 2 */静的なconst uint32_t K64=; { 0x428a2f98、0×71374491 0xb5c0fbcf、0xe9b5dba5、0x3956c25b、0x59f111f1、0x923f82a4、0xab1c5ed5、0xd807aa98、0x12835b01、0x243185be、0x550c7dc3、0x72be5d74、0x80deb1fe、0x9bdc06a7、0xc19bf174、0xe49b69c1、0xefbe4786、0x0fc19dc6、0x240ca1cc、0x2de92c6f、0x4a7484aa、0x5cb0a9dc、0x76f988da、0x983e5152、0xa831c66d、0xb00327c8、0xbf597fc7、0xc6e00bf3、0xd5a79147、0x06ca6351、0×14292967; 0x27b70a85、0x2e1b2138、0x4d2c6dfc、0x53380d13、0x650a7354、0x766a0abb、0x81c2c92e、0x92722c85、0xa2bfe8a1、0xa81a664b、0xc24b8b70、0xc76c51a3、0xd192e819、0xd6990624、0xf40e3585、0x106aa070、0x19a4c116、0x1e376c08、0x2748774c、0x34b0bcb5、0x391c0cb3、0x4ed8aa4a、0x5b9cca4f、0x682e6ff3、0x748f82ee、0x78a5636f、0x84c87814、0x8cc70208、0x90befffa、0xa4506ceb、0xbef9a3f7、0xc67178f2; } int t、t4; _/*ループ・カウンタ*/uint32t temp1temp2; _/*一時的な単語価値*/uint32t W64; /*H、系列*/uint32_t A、B、C、D、E、F、Gを言い表してください; /*はバッファ*/を言い表します。

  /*
   * Initialize the first 16 words in the array W
   */
  for (t = t4 = 0; t < 16; t++, t4 += 4)
    W[t] = (((uint32_t)context->Message_Block[t4]) << 24) |
           (((uint32_t)context->Message_Block[t4 + 1]) << 16) |
           (((uint32_t)context->Message_Block[t4 + 2]) << 8) |
           (((uint32_t)context->Message_Block[t4 + 3]));

/**は(tがt4=0; t<16; t++と等しく、t4+=4) W[t]=(uint32_t)文脈->はMessage_Block[t4]です)<<24)のためにアレイW*/の最初の16の単語を初期化します。| ((メッセージ_が妨げる(uint32_t)文脈->[t4+1])<<16) | ((メッセージ_が妨げる(uint32_t)文脈->[t4+2])<<8) | ((メッセージ_が妨げる(uint32_t)文脈->[t4+3]))。

Eastlake 3rd & Hansen        Informational                     [Page 42]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[42ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

  for (t = 16; t < 64; t++)
    W[t] = SHA256_sigma1(W[t-2]) + W[t-7] +
        SHA256_sigma0(W[t-15]) + W[t-16];

(t=16; t<64; t++)に関しては、W[t]はSHA256_sigma1(W[t-2])+W[t-7]+SHA256_sigma0(W[t-15])+W[t-16]と等しいです。

  A = context->Intermediate_Hash[0];
  B = context->Intermediate_Hash[1];
  C = context->Intermediate_Hash[2];
  D = context->Intermediate_Hash[3];
  E = context->Intermediate_Hash[4];
  F = context->Intermediate_Hash[5];
  G = context->Intermediate_Hash[6];
  H = context->Intermediate_Hash[7];

=文脈->中間的な_細切れ肉料理[0]。 Bは文脈->中間的な_細切れ肉料理[1]と等しいです。 Cは文脈->中間的な_細切れ肉料理[2]と等しいです。 Dは文脈->中間的な_細切れ肉料理[3]と等しいです。 Eは文脈->中間的な_細切れ肉料理[4]と等しいです。 Fは文脈->中間的な_細切れ肉料理[5]と等しいです。 Gは文脈->中間的な_細切れ肉料理[6]と等しいです。 Hは文脈->中間的な_細切れ肉料理[7]と等しいです。

  for (t = 0; t < 64; t++) {
    temp1 = H + SHA256_SIGMA1(E) + SHA_Ch(E,F,G) + K[t] + W[t];
    temp2 = SHA256_SIGMA0(A) + SHA_Maj(A,B,C);
    H = G;
    G = F;
    F = E;
    E = D + temp1;
    D = C;
    C = B;
    B = A;
    A = temp1 + temp2;
  }

(t=0; t<64; t++)のために{ temp1 = H + SHA256_SIGMA1(E) + SHA_Ch(E,F,G) + K[t] + W[t]; temp2 = SHA256_SIGMA0(A) + SHA_Maj(A,B,C); H = G; G = F; F = E; E = D + temp1; D = C; C = B; B = A; A = temp1 + temp2; }

  context->Intermediate_Hash[0] += A;
  context->Intermediate_Hash[1] += B;
  context->Intermediate_Hash[2] += C;
  context->Intermediate_Hash[3] += D;
  context->Intermediate_Hash[4] += E;
  context->Intermediate_Hash[5] += F;
  context->Intermediate_Hash[6] += G;
  context->Intermediate_Hash[7] += H;

文脈->中間的な_細切れ肉料理[0]+=A。 文脈->中間的な_細切れ肉料理[1]+=B。 文脈->中間的な_細切れ肉料理[2]+=C。 文脈->中間的な_細切れ肉料理[3]+=D。 文脈->中間的な_細切れ肉料理[4]+=E。 文脈->中間的な_細切れ肉料理[5]+=F。 文脈->中間的な_細切れ肉料理[6]+=G。 文脈->中間的な_細切れ肉料理[7]+=H。

  context->Message_Block_Index = 0;
}

メッセージ_ブロック_が索引をつける文脈->は0と等しいです。 }

/*
 * SHA224_256Reset
 *
 * Description:
 *   This helper function will initialize the SHA256Context in
 *   preparation for computing a new SHA256 message digest.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to reset.

/**SHA224_256Reset**記述: * このヘルパー機能は新しいSHA256メッセージダイジェストを計算するための*準備でSHA256Contextを初期化するでしょう。 * * パラメタ: * 文脈: [/アウト] *のリセットする文脈。

Eastlake 3rd & Hansen        Informational                     [Page 43]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[43ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 *   H0
 *     The initial hash value to use.
 *
 * Returns:
 *   sha Error Code.
 */
static int SHA224_256Reset(SHA256Context *context, uint32_t *H0)
{
  if (!context)
    return shaNull;

* 初期の細切れ肉料理が使用に評価するH0*。 * * リターン: * sha Error Code。 */静的なint SHA224_256Reset(SHA256Context*文脈、uint32_t*H0)、(文脈)であるなら、shaNullを返してください。

  context->Length_Low           = 0;
  context->Length_High          = 0;
  context->Message_Block_Index  = 0;

文脈、->長さ_安値は0と等しいです。 文脈、->長さ_高値は0と等しいです。 メッセージ_ブロック_が索引をつける文脈->は0と等しいです。

  context->Intermediate_Hash[0] = H0[0];
  context->Intermediate_Hash[1] = H0[1];
  context->Intermediate_Hash[2] = H0[2];
  context->Intermediate_Hash[3] = H0[3];
  context->Intermediate_Hash[4] = H0[4];
  context->Intermediate_Hash[5] = H0[5];
  context->Intermediate_Hash[6] = H0[6];
  context->Intermediate_Hash[7] = H0[7];

文脈->中間的な_細切れ肉料理[0]はH0[0]と等しいです。 文脈->中間的な_細切れ肉料理[1]はH0[1]と等しいです。 文脈->中間的な_細切れ肉料理[2]はH0[2]と等しいです。 文脈->中間的な_細切れ肉料理[3]はH0[3]と等しいです。 文脈->中間的な_細切れ肉料理[4]はH0[4]と等しいです。 文脈->中間的な_細切れ肉料理[5]はH0[5]と等しいです。 文脈->中間的な_細切れ肉料理[6]はH0[6]と等しいです。 文脈->中間的な_細切れ肉料理[7]はH0[7]と等しいです。

  context->Computed  = 0;
  context->Corrupted = 0;

文脈->が計算された=0。 文脈->が崩壊している=0。

  return shaSuccess;
}

shaSuccessを返してください。 }

/*
 * SHA224_256ResultN
 *
 * Description:
 *   This helper function will return the 224-bit or 256-bit message
 *   digest into the Message_Digest array provided by the caller.
 *   NOTE: The first octet of hash is stored in the 0th element,
 *      the last octet of hash in the 28th/32nd element.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to use to calculate the SHA hash.
 *   Message_Digest: [out]
 *     Where the digest is returned.
 *   HashSize: [in]
 *     The size of the hash, either 28 or 32.
 *
 * Returns:

/**SHA224_256ResultN**記述: * このヘルパー機能は224ビットの、または、256ビットのメッセージ*ダイジェストを訪問者によって提供されたMessage_Digestアレイに返すでしょう。 * 以下に注意してください。 細切れ肉料理の最初の八重奏は0番目の要素に格納されます、*。第28/第32要素における、細切れ肉料理の最後の八重奏。 * * パラメタ: * 文脈: [/アウト] *のSHA細切れ肉料理について計算するのに使用する文脈。 * メッセージ_は読みこなします: ダイジェストが返される[out]*。 * HashSize: 細切れ肉料理のサイズの[in]*、28か32。 * * リターン:

Eastlake 3rd & Hansen        Informational                     [Page 44]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[44ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 *   sha Error Code.
 */
static int SHA224_256ResultN(SHA256Context *context,
    uint8_t Message_Digest[], int HashSize)
{
  int i;

* sha Error Code。 */静的なint SHA224_256ResultN(SHA256Context*文脈、uint8_t Message_Digest[]、int HashSize)、int i。

  if (!context || !Message_Digest)
    return shaNull;

(Message_Digest| 文脈| )がshaNullを返すなら。

  if (context->Corrupted)
    return context->Corrupted;

(文脈、-、>Corrupted) 文脈->にCorruptedを返してください。

  if (!context->Computed)
    SHA224_256Finalize(context, 0x80);

(計算された文脈->)SHA224_256Finalize(文脈、0×80)であるなら。

  for (i = 0; i < HashSize; ++i)
    Message_Digest[i] = (uint8_t)
      (context->Intermediate_Hash[i>>2] >> 8 * ( 3 - ( i & 0x03 ) ));

(i=0; i<HashSize; + + i)メッセージ_Digest[i]=(uint8_t)、(文脈、-、>Intermediate_Hash[i>>2]>>8*(3--(iと0×03))。

  return shaSuccess;
}

shaSuccessを返してください。 }

8.2.3.  sha384-512.c

8.2.3. sha384-512.c

/*************************** sha384-512.c ***************************/
/********************* See RFC 4634 for details *********************/
/*
 * Description:
 *   This file implements the Secure Hash Signature Standard
 *   algorithms as defined in the National Institute of Standards
 *   and Technology Federal Information Processing Standards
 *   Publication (FIPS PUB) 180-1 published on April 17, 1995, 180-2
 *   published on August 1, 2002, and the FIPS PUB 180-2 Change
 *   Notice published on February 28, 2004.
 *
 *   A combined document showing all algorithms is available at
 *       http://csrc.nist.gov/publications/fips/
 *       fips180-2/fips180-2withchangenotice.pdf
 *
 *   The SHA-384 and SHA-512 algorithms produce 384-bit and 512-bit
 *   message digests for a given data stream. It should take about
 *   2**n steps to find a message with the same digest as a given
 *   message and 2**(n/2) to find any two messages with the same
 *   digest, when n is the digest size in bits. Therefore, this
 *   algorithm can serve as a means of providing a
 *   "fingerprint" for a message.
 *

見る..詳細..記述 * このファイルはStandards*のNational Instituteで定義されるSecure Hash Signature Standard*アルゴリズム、1995年4月17日に発行された、Technology連邦政府の情報Processing Standards*公表(FIPS PUB)180-1、2002年8月1日に発行された180-2*、および2004年2月28日に発表されたFIPS PUB180-2Change*通知を実行します。 * * すべてのアルゴリズムを示している結合したドキュメントは* http://csrc.nist.gov/publications/fips/ *fips180-2/fips180-2withchangenotice.pdfで利用可能です。**SHA-384とSHA-512アルゴリズムは与えられたデータ・ストリームのための384ビットの、そして、512ビットの*メッセージダイジェストを作成します。 それは同じ*ダイジェストでどんな2つのメッセージも見つけるために与えられた*メッセージと2**(n/2)と同じダイジェストでメッセージを見つけるには*2**に関してnステップでかかるべきです、nがビットのダイジェストサイズであるときに。 したがって、この*アルゴリズムは*「指紋」をメッセージに提供する手段として機能できます。 *

Eastlake 3rd & Hansen        Informational                     [Page 45]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[45ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 * Portability Issues:
 *   SHA-384 and SHA-512 are defined in terms of 64-bit "words",
 *   but if USE_32BIT_ONLY is #defined, this code is implemented in
 *   terms of 32-bit "words". This code uses <stdint.h> (included
 *   via "sha.h") to define the 64, 32 and 8 bit unsigned integer
 *   types. If your C compiler does not support 64 bit unsigned
 *   integers, and you do not #define USE_32BIT_ONLY, this code is
 *   not appropriate.
 *
 * Caveats:
 *   SHA-384 and SHA-512 are designed to work with messages less
 *   than 2^128 bits long. This implementation uses
 *   SHA384/512Input() to hash the bits that are a multiple of the
 *   size of an 8-bit character, and then uses SHA384/256FinalBits()
 *   to hash the final few bits of the input.
 *
 */

* 移植性の問題: * SHA-384とSHA-512は64ビットの「単語」で定義されます、*にもかかわらず、唯一のUSE_32BITが定義された#であるなら、このコードは32ビットの「単語」の*用語で実行されます。 32と8ビットの符号のない整数*タイプ、このコードは64を定義するのに、<stdint.h>("sha.h"を通して*を含んでいる)を使用します。 #Cコンパイラが整数、およびあなたが支持しない64ビットの無記名の*を支持しないなら、USE_32BITだけを定義してください、そして、このコードは*です。適切でない。 * * 警告: * SHA-384とSHA-512は、2^128ビットより少ないメッセージ*が長い状態で働くように設計されています。 この実現は、8ビットのキャラクタの*サイズの倍数であるビットを論じ尽くすのに*SHA384/512Input()を使用して、次に、入力の最終的な数ビットしか論じ尽くさないようにSHA384/256FinalBits()*を使用します。 * */

#include "sha.h"
#include "sha-private.h"

##、が含む"sha.h""sha-private.h"を含めてください。

#ifdef USE_32BIT_ONLY
/*
 * Define 64-bit arithmetic in terms of 32-bit arithmetic.
 * Each 64-bit number is represented in a 2-word array.
 * All macros are defined such that the result is the last parameter.
 */

#ifdef USE_32BIT、_/**は32ビットの演算で64ビットの演算を定義するだけです。 * それぞれの64ビットの数は2単語のアレイに表されます。 * すべてのマクロが定義されるので、結果は最後のパラメタです。 */

/*
 * Define shift, rotate left and rotate right functions
 */
#define SHA512_SHR(bits, word, ret) (                          \
    /* (((uint64_t)((word))) >> (bits)) */                     \
    (ret)[0] = (((bits) < 32) && ((bits) >= 0)) ?              \
      ((word)[0] >> (bits)) : 0,                               \
    (ret)[1] = ((bits) > 32) ? ((word)[0] >> ((bits) - 32)) :  \
      ((bits) == 32) ? (word)[0] :                             \
      ((bits) >= 0) ?                                          \
        (((word)[0] << (32 - (bits))) |                        \
        ((word)[1] >> (bits))) : 0 )

/**がシフトを定義して、左に回転して、回転する、正しい機能*/#はSHA512_SHRを定義します(ビット(単語)は浸水します)。( \ /* (((uint64_t)((word))) >> (bits)) */ \ (ret)[0] = (((bits) < 32) && ((bits) >= 0)) ? \ ((word)[0] >> (bits)) : 0, \ (ret)[1] = ((bits) > 32) ? ((word)[0] >> ((bits) - 32)) : \ ((bits) == 32) ? (word)[0] : \ ((bits) >= 0) ? \ (((word)[0] << (32 - (bits))) | \ ((word)[1] >> (bits))) : 0 )

#define SHA512_SHL(bits, word, ret) (                          \
    /* (((uint64_t)(word)) << (bits)) */                       \
    (ret)[0] = ((bits) > 32) ? ((word)[1] << ((bits) - 32)) :  \
         ((bits) == 32) ? (word)[1] :                          \
         ((bits) >= 0) ?                                       \
           (((word)[0] << (bits)) |                            \
           ((word)[1] >> (32 - (bits)))) :                     \

#define SHA512_SHL(bits, word, ret) ( \ /* (((uint64_t)(word)) << (bits)) */ \ (ret)[0] = ((bits) > 32) ? ((word)[1] << ((bits) - 32)) : \ ((bits) == 32) ? (word)[1] : \ ((bits) >= 0) ? \ (((word)[0] << (bits)) | \ ((word)[1] >> (32 - (bits)))) : \

Eastlake 3rd & Hansen        Informational                     [Page 46]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[46ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

         0,                                                    \
    (ret)[1] = (((bits) < 32) && ((bits) >= 0)) ?              \
        ((word)[1] << (bits)) : 0 )

0、\(浸水する)[1]が(ビット)>=0)円(単語)の<32と等しい、(ビット)[1]<<(ビット): 0 )

/*
 * Define 64-bit OR
 */
#define SHA512_OR(word1, word2, ret) (                         \
    (ret)[0] = (word1)[0] | (word2)[0],                        \
    (ret)[1] = (word1)[1] | (word2)[1] )

/**が定義する、64ビットのOR*/#、はSHA512_ORを定義します(word1、word2は浸水します)。(\(浸水する)[0]は(word1)[0]と等しいです| (word2)[0]、\(浸水する)[1]は(word1)[1]| (word2)[1] )と等しいです。

/*
 * Define 64-bit XOR
 */
#define SHA512_XOR(word1, word2, ret) (                        \
    (ret)[0] = (word1)[0] ^ (word2)[0],                        \
    (ret)[1] = (word1)[1] ^ (word2)[1] )

/**はXOR*/#が定義する64ビットSHA512_XORを定義します(word1、word2は浸水します)。(\(浸水する)[0]は(word1)[0]^(word2)[0]、\(浸水する)[1]=(word1)[1]^(word2)[1] )と等しいです。

/*
 * Define 64-bit AND
 */
#define SHA512_AND(word1, word2, ret) (                        \
    (ret)[0] = (word1)[0] & (word2)[0],                        \
    (ret)[1] = (word1)[1] & (word2)[1] )

/**は64ビットを定義します、そして、*/#、はSHA512_ANDを定義します(word1、word2は浸水します)。(\(浸水する)[0]=(word1)[0]と(word2)[0]、\(浸水する)[1]=(word1)[1]、および(word2)[1] )

/*
 * Define 64-bit TILDA
 */
#define SHA512_TILDA(word, ret)                                \
  ( (ret)[0] = ~(word)[0], (ret)[1] = ~(word)[1] )

/**がティルダ*/#、が定義する64ビットSHA512_ティルダを定義する、(単語、浸水、)、\(浸水します) [0] = ~(単語)[0]、(浸水します)[1]は~(単語)[1] )と等しいです。

/*
 * Define 64-bit ADD
 */
#define SHA512_ADD(word1, word2, ret) (                        \
    (ret)[1] = (word1)[1], (ret)[1] += (word2)[1],             \
    (ret)[0] = (word1)[0] + (word2)[0] + ((ret)[1] < (word1)[1]) )

/**はADD*/#が定義する64ビットSHA512_ADDを定義します(word1、word2は浸水します)。(\(浸水する)[1]は(word1)[1]と等しく、(浸水します)[1]+=(word2)[1]、\(浸水する)[0]は[0] + [0] + [1] (word2)(浸水します)<(word1)[1]) )と等しいです(word1)。

/*
 * Add the 4word value in word2 to word1.
 */
static uint32_t ADDTO4_temp, ADDTO4_temp2;
#define SHA512_ADDTO4(word1, word2) (                          \
    ADDTO4_temp = (word1)[3],                                  \
    (word1)[3] += (word2)[3],                                  \
    ADDTO4_temp2 = (word1)[2],                                 \
    (word1)[2] += (word2)[2] + ((word1)[3] < ADDTO4_temp),     \
    ADDTO4_temp = (word1)[1],                                  \

/**はword2で4word価値をword1に高めます。 */静的なuint32_t ADDTO4_臨時、ADDTO4_temp2。 #SHA512_ADDTO4(word1、word2)(\ADDTO4_臨時=(word1)[3]、\(word1)[3]+=(word2)[3]、\ADDTO4_temp2は(word1)[2]と等しいです、\(word1)[2]+=(word2)[2]+(word1)[3]<ADDTO4_臨時)を定義してください、\ADDTO4_臨時=(word1)[1]、\

Eastlake 3rd & Hansen        Informational                     [Page 47]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[47ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

    (word1)[1] += (word2)[1] + ((word1)[2] < ADDTO4_temp2),    \
    (word1)[0] += (word2)[0] + ((word1)[1] < ADDTO4_temp) )

(word1)[1]+=(word2)[1]+((word1)[2]<ADDTO4_temp2)、\(word1)[0]+=(word2)[0]+(word1)[1]<ADDTO4_臨時)

/*
 * Add the 2word value in word2 to word1.
 */
static uint32_t ADDTO2_temp;
#define SHA512_ADDTO2(word1, word2) (                          \
    ADDTO2_temp = (word1)[1],                                  \
    (word1)[1] += (word2)[1],                                  \
    (word1)[0] += (word2)[0] + ((word1)[1] < ADDTO2_temp) )

/**はword2で2word価値をword1に高めます。 */静的なuint32_t ADDTO2_臨時。 #SHA512_ADDTO2(word1、word2)を定義してください。(\ADDTO2_臨時=(word1) [1]、\(word1)[1]+=(word2)[1]、\(word1)[0]+=(word2)[0]+(word1)[1]<ADDTO2_は派遣社員として働きます))

/*
 * SHA rotate   ((word >> bits) | (word << (64-bits)))
 */
static uint32_t ROTR_temp1[2], ROTR_temp2[2];
#define SHA512_ROTR(bits, word, ret) (                         \
    SHA512_SHR((bits), (word), ROTR_temp1),                    \
    SHA512_SHL(64-(bits), (word), ROTR_temp2),                 \
    SHA512_OR(ROTR_temp1, ROTR_temp2, (ret)) )

/**SHAは*/静的なuint32_t ROTR_temp1[2]、ROTR_temp2[2]を回転させます((単語>>ビット)| (単語<<(64ビット)))。 #SHA512_ROTRを定義してください(ビット(単語)は浸水します)。(\SHA512_SHR((ビット)、(単語)、ROTR_temp1)、\SHA512_SHL(64(ビット)、(単語)、ROTR_temp2)、\SHA512_か(ROTR_temp1、ROTR_temp2(浸水します)))

/*
 * Define the SHA SIGMA and sigma macros
 *  SHA512_ROTR(28,word) ^ SHA512_ROTR(34,word) ^ SHA512_ROTR(39,word)
 */
static uint32_t SIGMA0_temp1[2], SIGMA0_temp2[2],
  SIGMA0_temp3[2], SIGMA0_temp4[2];
#define SHA512_SIGMA0(word, ret) (                             \
    SHA512_ROTR(28, (word), SIGMA0_temp1),                     \
    SHA512_ROTR(34, (word), SIGMA0_temp2),                     \
    SHA512_ROTR(39, (word), SIGMA0_temp3),                     \
    SHA512_XOR(SIGMA0_temp2, SIGMA0_temp3, SIGMA0_temp4),      \
    SHA512_XOR(SIGMA0_temp1, SIGMA0_temp4, (ret)) )

/**がSHA SIGMAとシグママクロ*SHA512_ROTRを定義する、(28、単語) ^SHA512_ROTR、(34、単語) ^SHA512_ROTR、(39、単語) */静的なuint32_t SIGMA0_temp1[2]、SIGMA0_temp2[2]、SIGMA0_temp3[2]、SIGMA0_temp4[2]。 #SHA512_SIGMA0を定義してください、(単語、浸水、)(\SHA512_ROTR(28、(単語)、SIGMA0_temp1)、\SHA512_ROTR(34、(単語)、SIGMA0_temp2)、\SHA512_ROTR(39、(単語)、SIGMA0_temp3)、\SHA512_XOR、(SIGMA0_temp2、SIGMA0_temp3、SIGMA0_temp4)、\SHA512_XOR(SIGMA0_temp1、SIGMA0_temp4(浸水します))

/*
 * SHA512_ROTR(14,word) ^ SHA512_ROTR(18,word) ^ SHA512_ROTR(41,word)
 */
static uint32_t SIGMA1_temp1[2], SIGMA1_temp2[2],
  SIGMA1_temp3[2], SIGMA1_temp4[2];
#define SHA512_SIGMA1(word, ret) (                             \
    SHA512_ROTR(14, (word), SIGMA1_temp1),                     \
    SHA512_ROTR(18, (word), SIGMA1_temp2),                     \
    SHA512_ROTR(41, (word), SIGMA1_temp3),                     \
    SHA512_XOR(SIGMA1_temp2, SIGMA1_temp3, SIGMA1_temp4),      \
    SHA512_XOR(SIGMA1_temp1, SIGMA1_temp4, (ret)) )

/**SHA512_ROTR、(14、単語) ^SHA512_ROTR、(18、単語) ^SHA512_ROTR、(41、単語) */静的なuint32_t SIGMA1_temp1[2]、SIGMA1_temp2[2]、SIGMA1_temp3[2]、SIGMA1_temp4[2]。 #SHA512_SIGMA1を定義してください、(単語、浸水、)(\SHA512_ROTR(14、(単語)、SIGMA1_temp1)、\SHA512_ROTR(18、(単語)、SIGMA1_temp2)、\SHA512_ROTR(41、(単語)、SIGMA1_temp3)、\SHA512_XOR、(SIGMA1_temp2、SIGMA1_temp3、SIGMA1_temp4)、\SHA512_XOR(SIGMA1_temp1、SIGMA1_temp4(浸水します))

/*
 * (SHA512_ROTR( 1,word) ^ SHA512_ROTR( 8,word) ^ SHA512_SHR( 7,word))

/* * (SHA512_ROTR、(1、単語) ^SHA512_ROTR、(8、単語) ^SHA512_SHR、(7、単語)

Eastlake 3rd & Hansen        Informational                     [Page 48]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[48ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 */
static uint32_t sigma0_temp1[2], sigma0_temp2[2],
  sigma0_temp3[2], sigma0_temp4[2];
#define SHA512_sigma0(word, ret) (                             \
    SHA512_ROTR( 1, (word), sigma0_temp1),                     \
    SHA512_ROTR( 8, (word), sigma0_temp2),                     \
    SHA512_SHR( 7, (word), sigma0_temp3),                      \
    SHA512_XOR(sigma0_temp2, sigma0_temp3, sigma0_temp4),      \
    SHA512_XOR(sigma0_temp1, sigma0_temp4, (ret)) )

*/静的なuint32_t sigma0_temp1[2]、sigma0_temp2[2]、sigma0_temp3[2]、sigma0_temp4[2]。 #SHA512_sigma0を定義してください、(単語、浸水、)(\SHA512_ROTR(1、(単語)、sigma0_temp1)、\SHA512_ROTR(8、(単語)、sigma0_temp2)、\SHA512_SHR(7、(単語)、sigma0_temp3)、\SHA512_XOR、(sigma0_temp2、sigma0_temp3、sigma0_temp4)、\SHA512_XOR(sigma0_temp1、sigma0_temp4(浸水します))

/*
 * (SHA512_ROTR(19,word) ^ SHA512_ROTR(61,word) ^ SHA512_SHR( 6,word))
 */
static uint32_t sigma1_temp1[2], sigma1_temp2[2],
  sigma1_temp3[2], sigma1_temp4[2];
#define SHA512_sigma1(word, ret) (                             \
    SHA512_ROTR(19, (word), sigma1_temp1),                     \
    SHA512_ROTR(61, (word), sigma1_temp2),                     \
    SHA512_SHR( 6, (word), sigma1_temp3),                      \
    SHA512_XOR(sigma1_temp2, sigma1_temp3, sigma1_temp4),      \
    SHA512_XOR(sigma1_temp1, sigma1_temp4, (ret)) )

/**、(SHA512_ROTR、(19、単語) ^SHA512_ROTR、(61、単語) ^SHA512_SHR、(6、単語) */静的なuint32_t sigma1_temp1[2]、sigma1_temp2[2]、sigma1_temp3[2]、sigma1_temp4[2]。 #SHA512_sigma1を定義してください、(単語、浸水、)(\SHA512_ROTR(19、(単語)、sigma1_temp1)、\SHA512_ROTR(61、(単語)、sigma1_temp2)、\SHA512_SHR(6、(単語)、sigma1_temp3)、\SHA512_XOR、(sigma1_temp2、sigma1_temp3、sigma1_temp4)、\SHA512_XOR(sigma1_temp1、sigma1_temp4(浸水します))

#undef SHA_Ch
#undef SHA_Maj

#undef SHA_Ch#undef SHA_マイ

#ifndef USE_MODIFIED_MACROS
/*
 * These definitions are the ones used in FIPS-180-2, section 4.1.3
 *  Ch(x,y,z)   ((x & y) ^ (~x & z))
 */
static uint32_t Ch_temp1[2], Ch_temp2[2], Ch_temp3[2];
#define SHA_Ch(x, y, z, ret) (                                 \
    SHA512_AND(x, y, Ch_temp1),                                \
    SHA512_TILDA(x, Ch_temp2),                                 \
    SHA512_AND(Ch_temp2, z, Ch_temp3),                         \
    SHA512_XOR(Ch_temp1, Ch_temp3, (ret)) )
/*
 *  Maj(x,y,z)  (((x)&(y)) ^ ((x)&(z)) ^ ((y)&(z)))
 */
static uint32_t Maj_temp1[2], Maj_temp2[2],
  Maj_temp3[2], Maj_temp4[2];
#define SHA_Maj(x, y, z, ret) (                                \
    SHA512_AND(x, y, Maj_temp1),                               \
    SHA512_AND(x, z, Maj_temp2),                               \
    SHA512_AND(y, z, Maj_temp3),                               \
    SHA512_XOR(Maj_temp2, Maj_temp3, Maj_temp4),               \
    SHA512_XOR(Maj_temp1, Maj_temp4, (ret)) )

#ifndef USE_MODIFIED_MACROS/、**これらの定義はFIPS-180-2で使用されるものです、セクション4.1.3*Ch(x、y、z)(xとy)^(~xとz)*/静的なuint32_t Ch_temp1[2]、Ch_temp2[2]、Ch_temp3[2]。 #定義..浸水..ティルダ..浸水..マイ..静的..マイ..マイ..マイ..マイ #SHA_マイを定義してください(x、y、zは浸水します)。(\SHA512_AND(x、y、マイ_temp1)、\SHA512_AND(x、z、マイ_temp2)、\SHA512_AND(y、z、マイ_temp3)、\SHA512_XOR、(マイ_temp2、マイ_temp3、マイ_temp4)、\SHA512_XOR(マイ_temp1、マイ_temp4(浸水します))

Eastlake 3rd & Hansen        Informational                     [Page 49]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[49ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

#else /* !USE_32BIT_ONLY */
/*
 * These definitions are potentially faster equivalents for the ones
 * used in FIPS-180-2, section 4.1.3.
 *   ((x & y) ^ (~x & z)) becomes
 *   ((x & (y ^ z)) ^ z)
 */
#define SHA_Ch(x, y, z, ret) (                                 \
   (ret)[0] = (((x)[0] & ((y)[0] ^ (z)[0])) ^ (z)[0]),         \
   (ret)[1] = (((x)[1] & ((y)[1] ^ (z)[1])) ^ (z)[1]) )

#ほかの/*!USE_32BITだけ、*//、**これらの定義はFIPS-180-2、セクション4.1で.3に使用されるもの*のための潜在的により速い同等物です。 * (xとy) ^(~xとz) なる、*(xと(y^z))^z)*/#、はSHA_Chを定義します(x、y、zは浸水します)。(((y) [1] (((x) \(浸水する)[0]=[0]、((y) [0] ^(z)[0]))^(z)[0])、(((x) \(浸水する)[1]=[1]、および^(z)[1]))^(z)[1]) )

/*
 *   ((x & y) ^ (x & z) ^ (y & z)) becomes
 *   ((x & (y | z)) | (y & z))
 */
#define SHA_Maj(x, y, z, ret) (                                 \
   ret[0] = (((x)[0] & ((y)[0] | (z)[0])) | ((y)[0] & (z)[0])), \
   ret[1] = (((x)[1] & ((y)[1] | (z)[1])) | ((y)[1] & (z)[1])) )
#endif /* USE_MODIFIED_MACROS */

/**(xとy)^(xとz)^(yとz)は*(xと(y| z))になります| (yとz)*/#、はSHA_マイを定義します(x、y、zは浸水します)。(\は[0] =(((x)[0]と((y) [0]を浸水させます| (z) [0]))| ((y)[0]と(z)[0]))、\は[1] =(((x)[1]と((y) [1]| (z)[1]))を浸水させます|、((y)[1]と(z)[1])) )#endif/*USE_MODIFIED_MACROS*/

/*
 * add "length" to the length
 */
static uint32_t addTemp[4] = { 0, 0, 0, 0 };
#define SHA384_512AddLength(context, length) (                        \
    addTemp[3] = (length), SHA512_ADDTO4((context)->Length, addTemp), \
    (context)->Corrupted = (((context)->Length[3] == 0) &&            \
       ((context)->Length[2] == 0) && ((context)->Length[1] == 0) &&  \
       ((context)->Length[0] < 8)) ? 1 : 0 )

/**は0、0、0、長さ*/静的なuint32_t addTemp[4]=0に「長さ」を加えます。 #SHA384_512AddLength(文脈、長さ)を定義してください。(\addTemp[3]は(長さ)と等しく、SHA512_ADDTO4(文脈)->は長さです、addTemp)、\(文脈)->が=(文脈)>長さ[3]=を崩壊させた、0、)、\(文脈)>長さ[2]=、0、)、(文脈)>長さ[1]=、0、)、\((文脈)>長さ[0]<8)--1:0)

/* Local Function Prototypes */
static void SHA384_512Finalize(SHA512Context *context,
  uint8_t Pad_Byte);
static void SHA384_512PadMessage(SHA512Context *context,
  uint8_t Pad_Byte);
static void SHA384_512ProcessMessageBlock(SHA512Context *context);
static int SHA384_512Reset(SHA512Context *context, uint32_t H0[]);
static int SHA384_512ResultN( SHA512Context *context,
  uint8_t Message_Digest[], int HashSize);

/*地方のFunction Prototypes*/静電気はSHA384_512Finalize(SHA512Context*文脈、uint8_t Pad_Byte)を欠如させます。 静的な空のSHA384_512PadMessage(SHA512Context*文脈、uint8_t Pad_Byte)。 静的な空のSHA384_512ProcessMessageBlock(SHA512Context*文脈)。 静的なint SHA384_512Reset、(SHA512Context*文脈、uint32_t H0[])。 静的なint SHA384_512ResultN(SHA512Context*文脈、uint8_t Message_Digest[]、int HashSize)。

/* Initial Hash Values: FIPS-180-2 sections 5.3.3 and 5.3.4 */
static uint32_t SHA384_H0[SHA512HashSize/4] = {
    0xCBBB9D5D, 0xC1059ED8, 0x629A292A, 0x367CD507, 0x9159015A,
    0x3070DD17, 0x152FECD8, 0xF70E5939, 0x67332667, 0xFFC00B31,
    0x8EB44A87, 0x68581511, 0xDB0C2E0D, 0x64F98FA7, 0x47B5481D,
    0xBEFA4FA4
};

/*初期のハッシュ値: FIPS-180-2部5.3の.3と5.3の.4の*/静的なuint32_t SHA384_H0[SHA512HashSize/4]は0xCBBB9D5D、0xC1059ED8、0x629A292A、0x367CD507、0x9159015A、0x3070DD17、0x152FECD8、0xF70E5939、0×67332667、0xFFC00B31、0x8EB44A87、0×68581511、0xDB0C2E0D、0x64F98FA7、0x47B5481D、0xBEFA4FA4と等しいです。

Eastlake 3rd & Hansen        Informational                     [Page 50]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[50ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

static uint32_t SHA512_H0[SHA512HashSize/4] = {
    0x6A09E667, 0xF3BCC908, 0xBB67AE85, 0x84CAA73B, 0x3C6EF372,
    0xFE94F82B, 0xA54FF53A, 0x5F1D36F1, 0x510E527F, 0xADE682D1,
    0x9B05688C, 0x2B3E6C1F, 0x1F83D9AB, 0xFB41BD6B, 0x5BE0CD19,
    0x137E2179
};

静的なuint32_t SHA512_H0[SHA512HashSize/4]は0x6A09E667、0xF3BCC908、0xBB67AE85、0x84CAA73B、0x3C6EF372、0xFE94F82B、0xA54FF53A、0x5F1D36F1、0x510E527F、0xADE682D1、0x9B05688C、0x2B3E6C1F、0x1F83D9AB、0xFB41BD6B、0x5BE0CD19、0x137E2179と等しいです。

#else /* !USE_32BIT_ONLY */

#ほかの/*!USE_32BITだけ、*/

/* Define the SHA shift, rotate left and rotate right macro */
#define SHA512_SHR(bits,word)  (((uint64_t)(word)) >> (bits))
#define SHA512_ROTR(bits,word) ((((uint64_t)(word)) >> (bits)) | \
                                (((uint64_t)(word)) << (64-(bits))))

/*がSHAシフトを定義して、左に回転して、*/#、が定義する正しいマクロを回転させる、SHA512_SHR(単語) ビット、(uint64_t)(単語)>>(ビット))#、はSHA512_ROTR(ビット、単語)を定義します。((uint64_t)(単語)>>(ビット))| \(((uint64_t)(単語)<<(64(ビット))))

/* Define the SHA SIGMA and sigma macros */
#define SHA512_SIGMA0(word)   \
 (SHA512_ROTR(28,word) ^ SHA512_ROTR(34,word) ^ SHA512_ROTR(39,word))
#define SHA512_SIGMA1(word)   \
 (SHA512_ROTR(14,word) ^ SHA512_ROTR(18,word) ^ SHA512_ROTR(41,word))
#define SHA512_sigma0(word)   \
 (SHA512_ROTR( 1,word) ^ SHA512_ROTR( 8,word) ^ SHA512_SHR( 7,word))
#define SHA512_sigma1(word)   \
 (SHA512_ROTR(19,word) ^ SHA512_ROTR(61,word) ^ SHA512_SHR( 6,word))

/* Define the SHA SIGMA and sigma macros */ #define SHA512_SIGMA0(word) \ (SHA512_ROTR(28,word) ^ SHA512_ROTR(34,word) ^ SHA512_ROTR(39,word)) #define SHA512_SIGMA1(word) \ (SHA512_ROTR(14,word) ^ SHA512_ROTR(18,word) ^ SHA512_ROTR(41,word)) #define SHA512_sigma0(word) \ (SHA512_ROTR( 1,word) ^ SHA512_ROTR( 8,word) ^ SHA512_SHR( 7,word)) #define SHA512_sigma1(word) \ (SHA512_ROTR、(19、単語) ^SHA512_ROTR、(61、単語) ^SHA512_SHR、(6、単語)

/*
 * add "length" to the length
 */
static uint64_t addTemp;
#define SHA384_512AddLength(context, length)                   \
   (addTemp = context->Length_Low, context->Corrupted =        \
    ((context->Length_Low += length) < addTemp) &&             \
    (++context->Length_High == 0) ? 1 : 0)

/**は長さ*/静的なuint64_t addTempに「長さ」を加えます。 #SHA384_512AddLength(文脈、長さ)\を定義してください。(addTemp=文脈、-、>Length_Low、文脈->、Corruptedが\と等しい、(文脈、->Length_Low+が長さ) <addTempと等しい、)、\、(+ + 文脈、-、>Length_High=0)? 1:0、)

/* Local Function Prototypes */
static void SHA384_512Finalize(SHA512Context *context,
  uint8_t Pad_Byte);
static void SHA384_512PadMessage(SHA512Context *context,
  uint8_t Pad_Byte);
static void SHA384_512ProcessMessageBlock(SHA512Context *context);
static int SHA384_512Reset(SHA512Context *context, uint64_t H0[]);
static int SHA384_512ResultN(SHA512Context *context,
  uint8_t Message_Digest[], int HashSize);

/*地方のFunction Prototypes*/静電気はSHA384_512Finalize(SHA512Context*文脈、uint8_t Pad_Byte)を欠如させます。 静的な空のSHA384_512PadMessage(SHA512Context*文脈、uint8_t Pad_Byte)。 静的な空のSHA384_512ProcessMessageBlock(SHA512Context*文脈)。 静的なint SHA384_512Reset、(SHA512Context*文脈、uint64_t H0[])。 静的なint SHA384_512ResultN(SHA512Context*文脈、uint8_t Message_Digest[]、int HashSize)。

/* Initial Hash Values: FIPS-180-2 sections 5.3.3 and 5.3.4 */
static uint64_t SHA384_H0[] = {
    0xCBBB9D5DC1059ED8ll, 0x629A292A367CD507ll, 0x9159015A3070DD17ll,
    0x152FECD8F70E5939ll, 0x67332667FFC00B31ll, 0x8EB44A8768581511ll,
    0xDB0C2E0D64F98FA7ll, 0x47B5481DBEFA4FA4ll

/*初期のハッシュ値: FIPS-180-2部5.3の.3と5.3の.4の*/静的なuint64_t SHA384_H0[]が等しい、0xCBBB9D5DC1059ED8ll、0x629A292A367CD507ll、0x9159015A3070DD17ll、0x152FECD8F70E5939ll、0x67332667FFC00B31ll、0x8EB44A8768581511ll、0xDB0C2E0D64F98FA7ll、0x47B5481DBEFA4FA4ll

Eastlake 3rd & Hansen        Informational                     [Page 51]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[51ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

};
static uint64_t SHA512_H0[] = {
    0x6A09E667F3BCC908ll, 0xBB67AE8584CAA73Bll, 0x3C6EF372FE94F82Bll,
    0xA54FF53A5F1D36F1ll, 0x510E527FADE682D1ll, 0x9B05688C2B3E6C1Fll,
    0x1F83D9ABFB41BD6Bll, 0x5BE0CD19137E2179ll
};

}; 静的なuint64_t SHA512_H0[]は0x6A09E667F3BCC908ll、0xBB67AE8584CAA73Bll、0x3C6EF372FE94F82Bll、0xA54FF53A5F1D36F1ll、0x510E527FADE682D1ll、0x9B05688C2B3E6C1Fll、0x1F83D9ABFB41BD6Bll、0x5BE0CD19137E2179llと等しいです。

#endif /* USE_32BIT_ONLY */

#endif/*USE_32BITだけ、*/

/*
 * SHA384Reset
 *
 * Description:
 *   This function will initialize the SHA384Context in preparation
 *   for computing a new SHA384 message digest.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to reset.
 *
 * Returns:
 *   sha Error Code.
 *
 */
int SHA384Reset(SHA384Context *context)
{
  return SHA384_512Reset(context, SHA384_H0);
}

/**SHA384Reset**記述: * この機能は新しいSHA384メッセージダイジェストを計算するための準備*でSHA384Contextを初期化するでしょう。 * * パラメタ: * 文脈: [/アウト] *のリセットする文脈。 * * リターン: * sha Error Code。 * */int SHA384Reset(SHA384Context*文脈)リターンSHA384_512Reset(文脈、SHA384_H0)。

/*
 * SHA384Input
 *
 * Description:
 *   This function accepts an array of octets as the next portion
 *   of the message.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   message_array: [in]
 *     An array of characters representing the next portion of
 *     the message.
 *   length: [in]
 *     The length of the message in message_array
 *
 * Returns:
 *   sha Error Code.
 *

/**SHA384Input**記述: * この機能はメッセージの次の部分*として八重奏の勢ぞろいを認めます。 * * パラメタ: * 文脈: アップデート*メッセージ_へのSHA文脈が整列させる[コネ/アウト]*: *次を表すキャラクタのアレイは*を分配します。[in]、メッセージ。 * 長さ: メッセージ_アレイ**のメッセージの長さの[in]*は戻ります: * sha Error Code。 *

Eastlake 3rd & Hansen        Informational                     [Page 52]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[52ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 */
int SHA384Input(SHA384Context *context,
    const uint8_t *message_array, unsigned int length)
{
  return SHA512Input(context, message_array, length);
}

*/int SHA384Input(SHA384Context*文脈、const uint8_t*メッセージ_アレイ、無記名のintの長さ)リターンSHA512Input(文脈、メッセージ_アレイ、長さ)。

/*
 * SHA384FinalBits
 *
 * Description:
 *   This function will add in any final bits of the message.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   message_bits: [in]
 *     The final bits of the message, in the upper portion of the
 *     byte. (Use 0b###00000 instead of 0b00000### to input the
 *     three bits ###.)
 *   length: [in]
 *     The number of bits in message_bits, between 1 and 7.
 *
 * Returns:
 *   sha Error Code.
 *
 */
int SHA384FinalBits(SHA384Context *context,
    const uint8_t message_bits, unsigned int length)
{
  return SHA512FinalBits(context, message_bits, length);
}

/**SHA384FinalBits**記述: * この機能はメッセージのどんな最終的なビットも加えるでしょう。 * * パラメタ: * 文脈: [コネ/アウト] **をアップデートするSHA文脈は_ビットを通信させます: [in]*、*バイトの上部のメッセージの最終的なビット。 (0b00000###の代わりに0b###00000、を使用して、*3ビット###、を入力してください。) * 長さ: [in]*はメッセージ_ビット、1〜7で、ビットの数です。 * * リターン: * sha Error Code。 * */int SHA384FinalBits(SHA384Context*文脈、const uint8_tメッセージ_ビット、無記名のintの長さ)リターンSHA512FinalBits(文脈、メッセージ_ビット、長さ)。

/*
 * SHA384Result
 *
 * Description:
 *   This function will return the 384-bit message
 *   digest into the Message_Digest array provided by the caller.
 *   NOTE: The first octet of hash is stored in the 0th element,
 *      the last octet of hash in the 48th element.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to use to calculate the SHA hash.
 *   Message_Digest: [out]
 *     Where the digest is returned.
 *

/**SHA384Result**記述: * この機能は訪問者によって提供されたMessage_Digestアレイに384ビットのメッセージ*ダイジェストを返すでしょう。 * 以下に注意してください。 細切れ肉料理の最初の八重奏は0番目の要素に格納されます、*。48番目の要素における、細切れ肉料理の最後の八重奏。 * * パラメタ: * 文脈: [/アウト] *のSHA細切れ肉料理について計算するのに使用する文脈。 * メッセージ_は読みこなします: ダイジェストが返される[out]*。 *

Eastlake 3rd & Hansen        Informational                     [Page 53]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[53ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 * Returns:
 *   sha Error Code.
 *
 */
int SHA384Result(SHA384Context *context,
    uint8_t Message_Digest[SHA384HashSize])
{
  return SHA384_512ResultN(context, Message_Digest, SHA384HashSize);
}

* リターン: * sha Error Code。 * */int SHA384Result(SHA384Context*文脈、uint8_t Message_Digest[SHA384HashSize])リターンSHA384_512ResultN(文脈、Message_Digest、SHA384HashSize)。

/*
 * SHA512Reset
 *
 * Description:
 *   This function will initialize the SHA512Context in preparation
 *   for computing a new SHA512 message digest.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to reset.
 *
 * Returns:
 *   sha Error Code.
 *
 */
int SHA512Reset(SHA512Context *context)
{
  return SHA384_512Reset(context, SHA512_H0);
}

/**SHA512Reset**記述: * この機能は新しいSHA512メッセージダイジェストを計算するための準備*でSHA512Contextを初期化するでしょう。 * * パラメタ: * 文脈: [/アウト] *のリセットする文脈。 * * リターン: * sha Error Code。 * */int SHA512Reset(SHA512Context*文脈)リターンSHA384_512Reset(文脈、SHA512_H0)。

/*
 * SHA512Input
 *
 * Description:
 *   This function accepts an array of octets as the next portion
 *   of the message.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   message_array: [in]
 *     An array of characters representing the next portion of
 *     the message.
 *   length: [in]
 *     The length of the message in message_array
 *
 * Returns:
 *   sha Error Code.

/**SHA512Input**記述: * この機能はメッセージの次の部分*として八重奏の勢ぞろいを認めます。 * * パラメタ: * 文脈: アップデート*メッセージ_へのSHA文脈が整列させる[コネ/アウト]*: *次を表すキャラクタのアレイは*を分配します。[in]、メッセージ。 * 長さ: メッセージ_アレイ**のメッセージの長さの[in]*は戻ります: * sha Error Code。

Eastlake 3rd & Hansen        Informational                     [Page 54]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[54ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 *
 */
int SHA512Input(SHA512Context *context,
        const uint8_t *message_array,
        unsigned int length)
{
  if (!length)
    return shaSuccess;

* */int SHA512Input(SHA512Context*文脈、const uint8_t*は_アレイ、無記名のintの長さを通信させる)、(長さ)であるなら、shaSuccessを返してください。

  if (!context || !message_array)
    return shaNull;

(メッセージ_アレイ| 文脈| )であるなら、shaNullを返してください。

  if (context->Computed) {
    context->Corrupted = shaStateError;
    return shaStateError;
  }

(文脈->は計算されていました)文脈、->CorruptedはshaStateErrorと等しいです; リターンshaStateError

  if (context->Corrupted)
     return context->Corrupted;

(文脈、-、>Corrupted) 文脈->にCorruptedを返してください。

  while (length-- && !context->Corrupted) {
    context->Message_Block[context->Message_Block_Index++] =
            (*message_array & 0xFF);

(長さ、--、崩壊する文脈->、)、文脈->は_ブロック[文脈->は_ブロック_インデックス++を通信させる]=(*メッセージ_アレイと0xFF)を通信させます。

    if (!SHA384_512AddLength(context, 8) &&
      (context->Message_Block_Index == SHA512_Message_Block_Size))
      SHA384_512ProcessMessageBlock(context);

(SHA384_512AddLength(文脈、8)、(文脈->は_ブロック_インデックス=SHA512_メッセージ_ブロック_サイズを通信させます)) SHA384_512ProcessMessageBlock(文脈)。

    message_array++;
  }

メッセージ_アレイ++。 }

  return shaSuccess;
}

shaSuccessを返してください。 }

/*
 * SHA512FinalBits
 *
 * Description:
 *   This function will add in any final bits of the message.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   message_bits: [in]
 *     The final bits of the message, in the upper portion of the
 *     byte. (Use 0b###00000 instead of 0b00000### to input the
 *     three bits ###.)
 *   length: [in]

/**SHA512FinalBits**記述: * この機能はメッセージのどんな最終的なビットも加えるでしょう。 * * パラメタ: * 文脈: [コネ/アウト] **をアップデートするSHA文脈は_ビットを通信させます: [in]*、*バイトの上部のメッセージの最終的なビット。 (0b00000###の代わりに0b###00000、を使用して、*3ビット###、を入力してください。) * 長さ: [in]

Eastlake 3rd & Hansen        Informational                     [Page 55]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[55ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 *     The number of bits in message_bits, between 1 and 7.
 *
 * Returns:
 *   sha Error Code.
 *
 */
int SHA512FinalBits(SHA512Context *context,
    const uint8_t message_bits, unsigned int length)
{
  uint8_t masks[8] = {
      /* 0 0b00000000 */ 0x00, /* 1 0b10000000 */ 0x80,
      /* 2 0b11000000 */ 0xC0, /* 3 0b11100000 */ 0xE0,
      /* 4 0b11110000 */ 0xF0, /* 5 0b11111000 */ 0xF8,
      /* 6 0b11111100 */ 0xFC, /* 7 0b11111110 */ 0xFE
  };
  uint8_t markbit[8] = {
      /* 0 0b10000000 */ 0x80, /* 1 0b01000000 */ 0x40,
      /* 2 0b00100000 */ 0x20, /* 3 0b00010000 */ 0x10,
      /* 4 0b00001000 */ 0x08, /* 5 0b00000100 */ 0x04,
      /* 6 0b00000010 */ 0x02, /* 7 0b00000001 */ 0x01
  };

* メッセージ_ビット、1〜7における、ビットの数。 * * リターン: * sha Error Code。 * */int SHA512FinalBits(SHA512Context*文脈、const uint8_tは_ビットを通信させます、無記名のintの長さ)、uint8_t masks8は/*0 0b00000000*/0x00、/*1 0b10000000*/0x80、/*2 0b11000000*/0xC0、/*3 0b11100000*/0xE0、/*4 0b11110000*/0xF0、/*5 0b11111000*/0xF8、/*6 0b11111100*/0xFC、/*7 0b11111110*/0xFEと等しいです; uint8_t markbit8は/*0 0b10000000*/0x80、/*1 0b01000000*/0x40、/*2 0b00100000*/0x20、/*3 0b00010000*/0x10、/*4 0b00001000*/0x08、/*5 0b00000100*/0x04、/*6 0b00000010*/0x02、/*7 0b00000001*/0x01と等しいです。

  if (!length)
    return shaSuccess;

(長さ)であるなら、shaSuccessを返してください。

  if (!context)
    return shaNull;

(文脈)であるなら、shaNullを返してください。

  if ((context->Computed) || (length >= 8) || (length == 0)) {
    context->Corrupted = shaStateError;
    return shaStateError;
  }

((文脈->は計算されました)| | (長さの>=8)| | (長さ=0))です。文脈、->CorruptedはshaStateErrorと等しいです; リターンshaStateError

  if (context->Corrupted)
     return context->Corrupted;

(文脈、-、>Corrupted) 文脈->にCorruptedを返してください。

  SHA384_512AddLength(context, length);
  SHA384_512Finalize(context, (uint8_t)
    ((message_bits & masks[length]) | markbit[length]));

SHA384_512AddLength(文脈、長さ)。 SHA384_512Finalize(文脈、(uint8_t)((メッセージ_ビットとマスク[長さ])| markbit[長さ]))。

  return shaSuccess;
}

shaSuccessを返してください。 }

/*
 * SHA384_512Finalize
 *
 * Description:
 *   This helper function finishes off the digest calculations.

/**SHA384_512Finalize**記述: * このヘルパー機能はダイジェスト計算を仕上げます。

Eastlake 3rd & Hansen        Informational                     [Page 56]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[56ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   Pad_Byte: [in]
 *     The last byte to add to the digest before the 0-padding
 *     and length. This will contain the last bits of the message
 *     followed by another single bit. If the message was an
 *     exact multiple of 8-bits long, Pad_Byte will be 0x80.
 *
 * Returns:
 *   sha Error Code.
 *
 */
static void SHA384_512Finalize(SHA512Context *context,
    uint8_t Pad_Byte)
{
  int_least16_t i;
  SHA384_512PadMessage(context, Pad_Byte);
  /* message may be sensitive, clear it out */
  for (i = 0; i < SHA512_Message_Block_Size; ++i)
    context->Message_Block[i] = 0;
#ifdef USE_32BIT_ONLY    /* and clear length */
  context->Length[0] = context->Length[1] = 0;
  context->Length[2] = context->Length[3] = 0;
#else /* !USE_32BIT_ONLY */
  context->Length_Low = 0;
  context->Length_High = 0;
#endif /* USE_32BIT_ONLY */
  context->Computed = 1;
}

* * パラメタ: * 文脈: [コネ/アウト] **をアップデートするSHA文脈は_Byteを水増しします: [in]*、0詰め物*の前にダイジェストに加える最後のバイトと長さ。 これは単一のもう1ビットが支えたメッセージ*の最後のビットを含むでしょう。 長い間メッセージが8ビットの*正確な倍数であったなら、Pad_Byteは0×80になるでしょう。 * * リターン: * sha Error Code。 * */静的な空のSHA384_512Finalize(SHA512Context*文脈、uint8_t Pad_Byte){ int_least16_t i; SHA384_512PadMessage(文脈、Pad_Byte); /*メッセージは機密であるかもしれなく、長さの文脈*/>Length0が文脈と等しいのが/*で明確な状態で(i=0; i<SHA512_Message_Block_Size; + + i)文脈->Message_Blocki=0 #ifdef USE_32BIT_だけのための*/からそれを晴れさせてください。->Length1は0と等しいです; 文脈、-0; #ほかの/*!使用_32ビットの_唯一の文脈*/>長さ_安値=0;文脈->長さ_高値=Length3=0 #endif/*使用_32が文脈->が*/計算されていたのに噛み付いただけである>Length2=文脈->は1と等しいです; }

/*
 * SHA512Result
 *
 * Description:
 *   This function will return the 512-bit message
 *   digest into the Message_Digest array provided by the caller.
 *   NOTE: The first octet of hash is stored in the 0th element,
 *      the last octet of hash in the 64th element.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to use to calculate the SHA hash.
 *   Message_Digest: [out]
 *     Where the digest is returned.
 *
 * Returns:

/**SHA512Result**記述: * この機能は訪問者によって提供されたMessage_Digestアレイに512ビットのメッセージ*ダイジェストを返すでしょう。 * 以下に注意してください。 細切れ肉料理の最初の八重奏は0番目の要素に格納されます、*。64番目の要素における、細切れ肉料理の最後の八重奏。 * * パラメタ: * 文脈: [/アウト] *のSHA細切れ肉料理について計算するのに使用する文脈。 * メッセージ_は読みこなします: ダイジェストが返される[out]*。 * * リターン:

Eastlake 3rd & Hansen        Informational                     [Page 57]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[57ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

 *   sha Error Code.
 *
 */
int SHA512Result(SHA512Context *context,
    uint8_t Message_Digest[SHA512HashSize])
{
  return SHA384_512ResultN(context, Message_Digest, SHA512HashSize);
}

* sha Error Code。 * */int SHA512Result(SHA512Context*文脈、uint8_t Message_Digest[SHA512HashSize])リターンSHA384_512ResultN(文脈、Message_Digest、SHA512HashSize)。

/*
 * SHA384_512PadMessage
 *
 * Description:
 *   According to the standard, the message must be padded to an
 *   even 1024 bits. The first padding bit must be a '1'. The
 *   last 128 bits represent the length of the original message.
 *   All bits in between should be 0. This helper function will
 *   pad the message according to those rules by filling the
 *   Message_Block array accordingly. When it returns, it can be
 *   assumed that the message digest has been computed.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to pad
 *   Pad_Byte: [in]
 *     The last byte to add to the digest before the 0-padding
 *     and length. This will contain the last bits of the message
 *     followed by another single bit. If the message was an
 *     exact multiple of 8-bits long, Pad_Byte will be 0x80.
 *
 * Returns:
 *   Nothing.
 *
 */
static void SHA384_512PadMessage(SHA512Context *context,
    uint8_t Pad_Byte)
{
  /*
   * Check to see if the current message block is too small to hold
   * the initial padding bits and length. If so, we will pad the
   * block, process it, and then continue padding into a second
   * block.
   */
  if (context->Message_Block_Index >= (SHA512_Message_Block_Size-16)) {
    context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
    while (context->Message_Block_Index < SHA512_Message_Block_Size)
      context->Message_Block[context->Message_Block_Index++] = 0;

/**SHA384_512PadMessage**記述: * 規格によると、*にメッセージを1024ビットさえ水増ししなければなりません。 最初の詰め物ビットは'1'であるに違いありません。 *最後の128ビットはオリジナルのメッセージの長さを表します。 * すべてのビット、0が中間であるべきです。 それらの規則に従って、このヘルパー機能は、*パッドにそれに従って、*メッセージ_Blockアレイをいっぱいにすることによって、メッセージを望んでいます。 戻ると、*が、メッセージダイジェストを計算してあると仮定したということであるかもしれません。 * * パラメタ: * 文脈: [コネ/アウト] **を水増しする文脈は_Byteを水増しします: [in]*、0詰め物*の前にダイジェストに加える最後のバイトと長さ。 これは単一のもう1ビットが支えたメッセージ*の最後のビットを含むでしょう。 長い間メッセージが8ビットの*正確な倍数であったなら、Pad_Byteは0×80になるでしょう。 * * リターン: * 何でもない。 * *現在のメッセージであるなら、ブロックは*が初期の詰め物ビットと長さであることを保持できないくらいわずかです。/静的な空のSHA384_512PadMessage(SHA512Context*文脈、uint8_t Pad_Byte)、そうだとすれば、私たちが、aの2*番目のブロック*/に*ブロックを水増しして、それを処理して、次に、そっと歩き続けるつもりであるのを確実にする/**チェック、(文脈、->Message_Block_Index>が(SHA512_Message_Block_Size-16)と等しい、文脈、-、Message_Block_Index++=が水増しする>Message_Blockcontext->、_Byte; (文脈->は_ブロック_インデックス<SHA512_メッセージ_ブロック_サイズを通信させます)文脈->メッセージ_Blockcontext->である間、_ブロック_インデックス++=0を通信させてください。

Eastlake 3rd & Hansen        Informational                     [Page 58]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[58ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

    SHA384_512ProcessMessageBlock(context);
  } else
    context->Message_Block[context->Message_Block_Index++] = Pad_Byte;

SHA384_512ProcessMessageBlock(文脈)。 ほかの文脈、-、>Message_Block、[文脈、->Message_Block_Index++] =は_Byteを水増しします。

  while (context->Message_Block_Index < (SHA512_Message_Block_Size-16))
    context->Message_Block[context->Message_Block_Index++] = 0;

(文脈->は_ブロック_インデックス<(SHA512_メッセージ_ブロック_サイズ-16)を通信させます)文脈->メッセージ_ブロック[文脈->は_ブロック_インデックス++を通信させる]=0をゆったり過ごしてください。

  /*
   * Store the message length as the last 16 octets
   */
#ifdef USE_32BIT_ONLY
  context->Message_Block[112] = (uint8_t)(context->Length[0] >> 24);
  context->Message_Block[113] = (uint8_t)(context->Length[0] >> 16);
  context->Message_Block[114] = (uint8_t)(context->Length[0] >> 8);
  context->Message_Block[115] = (uint8_t)(context->Length[0]);
  context->Message_Block[116] = (uint8_t)(context->Length[1] >> 24);
  context->Message_Block[117] = (uint8_t)(context->Length[1] >> 16);
  context->Message_Block[118] = (uint8_t)(context->Length[1] >> 8);
  context->Message_Block[119] = (uint8_t)(context->Length[1]);

/**がメッセージ長を格納する、ベスト16八重奏*/#ifdef USE_32BIT唯一の_文脈>として、Message_Block[112]が(uint8_t)と等しい、(文脈、-、>Length[0]>>24)。 文脈->が_ブロック[113]=(uint8_t)を通信させる、(文脈、-、>長さ[0]>>16)。 文脈->が_ブロック[114]=(uint8_t)を通信させる、(文脈、-、>長さ[0]>>8)。 文脈->が_ブロック[115]=(uint8_t)を通信させる、(文脈、-、>の長さ[0])。 文脈->が_ブロック[116]=(uint8_t)を通信させる、(文脈、-、>長さ[1]>>24)。 文脈->が_ブロック[117]=(uint8_t)を通信させる、(文脈、-、>長さ[1]>>16)。 文脈->が_ブロック[118]=(uint8_t)を通信させる、(文脈、-、>長さ[1]>>8)。 文脈->が_ブロック[119]=(uint8_t)を通信させる、(文脈、-、>の長さ[1])。

  context->Message_Block[120] = (uint8_t)(context->Length[2] >> 24);
  context->Message_Block[121] = (uint8_t)(context->Length[2] >> 16);
  context->Message_Block[122] = (uint8_t)(context->Length[2] >> 8);
  context->Message_Block[123] = (uint8_t)(context->Length[2]);
  context->Message_Block[124] = (uint8_t)(context->Length[3] >> 24);
  context->Message_Block[125] = (uint8_t)(context->Length[3] >> 16);
  context->Message_Block[126] = (uint8_t)(context->Length[3] >> 8);
  context->Message_Block[127] = (uint8_t)(context->Length[3]);
#else /* !USE_32BIT_ONLY */
  context->Message_Block[112] = (uint8_t)(context->Length_High >> 56);
  context->Message_Block[113] = (uint8_t)(context->Length_High >> 48);
  context->Message_Block[114] = (uint8_t)(context->Length_High >> 40);
  context->Message_Block[115] = (uint8_t)(context->Length_High >> 32);
  context->Message_Block[116] = (uint8_t)(context->Length_High >> 24);
  context->Message_Block[117] = (uint8_t)(context->Length_High >> 16);
  context->Message_Block[118] = (uint8_t)(context->Length_High >> 8);
  context->Message_Block[119] = (uint8_t)(context->Length_High);

文脈->が_ブロック[120]=(uint8_t)を通信させる、(文脈、-、>長さ[2]>>24)。 文脈->が_ブロック[121]=(uint8_t)を通信させる、(文脈、-、>長さ[2]>>16)。 文脈->が_ブロック[122]=(uint8_t)を通信させる、(文脈、-、>長さ[2]>>8)。 文脈->が_ブロック[123]=(uint8_t)を通信させる、(文脈、-、>の長さ[2])。 文脈->が_ブロック[124]=(uint8_t)を通信させる、(文脈、-、>長さ[3]>>24)。 文脈->が_ブロック[125]=(uint8_t)を通信させる、(文脈、-、>長さ[3]>>16)。 文脈->が_ブロック[126]=(uint8_t)を通信させる、(文脈、-、>長さ[3]>>8)。 文脈->が_ブロック[127]=(uint8_t)を通信させる、(文脈、-、>の長さ[3])。 #ほかの/*!USE_32BIT_唯一の文脈*/>Message_Block[112]=(uint8_t)、(文脈、-、>Length_High>>56)。 文脈->が_ブロック[113]=(uint8_t)を通信させる、(文脈、-、>長さ_の高い>>48)。 文脈->が_ブロック[114]=(uint8_t)を通信させる、(文脈、-、>長さ_の高い>>40)。 文脈->が_ブロック[115]=(uint8_t)を通信させる、(文脈、-、>長さ_の高い>>32)。 文脈->が_ブロック[116]=(uint8_t)を通信させる、(文脈、-、>長さ_の高い>>24)。 文脈->が_ブロック[117]=(uint8_t)を通信させる、(文脈、-、>長さ_の高い>>16)。 文脈->が_ブロック[118]=(uint8_t)を通信させる、(文脈、-、>長さ_の高い>>8)。 文脈->が_ブロック[119]=(uint8_t)を通信させる、(文脈、-、>長さ_高値)、。

  context->Message_Block[120] = (uint8_t)(context->Length_Low >> 56);
  context->Message_Block[121] = (uint8_t)(context->Length_Low >> 48);
  context->Message_Block[122] = (uint8_t)(context->Length_Low >> 40);
  context->Message_Block[123] = (uint8_t)(context->Length_Low >> 32);
  context->Message_Block[124] = (uint8_t)(context->Length_Low >> 24);
  context->Message_Block[125] = (uint8_t)(context->Length_Low >> 16);
  context->Message_Block[126] = (uint8_t)(context->Length_Low >> 8);
  context->Message_Block[127] = (uint8_t)(context->Length_Low);
#endif /* USE_32BIT_ONLY */

文脈->が_ブロック[120]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>56)。 文脈->が_ブロック[121]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>48)。 文脈->が_ブロック[122]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>40)。 文脈->が_ブロック[123]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>32)。 文脈->が_ブロック[124]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>24)。 文脈->が_ブロック[125]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>16)。 文脈->が_ブロック[126]=(uint8_t)を通信させる、(文脈、-、>長さ_の低い>>8)。 文脈->が_ブロック[127]=(uint8_t)を通信させる、(文脈、-、>長さ_安値)、。 #endif/*USE_32BITだけ、*/

Eastlake 3rd & Hansen        Informational                     [Page 59]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[59ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

  SHA384_512ProcessMessageBlock(context);
}

SHA384_512ProcessMessageBlock(文脈)。 }

/*
 * SHA384_512ProcessMessageBlock
 *
 * Description:
 *   This helper function will process the next 1024 bits of the
 *   message stored in the Message_Block array.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *
 * Returns:
 *   Nothing.
 *
 * Comments:
 *   Many of the variable names in this code, especially the
 *   single character names, were used because those were the
 *   names used in the publication.
 *
 *
 */
static void SHA384_512ProcessMessageBlock(SHA512Context *context)
{
  /* Constants defined in FIPS-180-2, section 4.2.3 */
#ifdef USE_32BIT_ONLY
  static const uint32_t K[80*2] = {
      0x428A2F98, 0xD728AE22, 0x71374491, 0x23EF65CD, 0xB5C0FBCF,
      0xEC4D3B2F, 0xE9B5DBA5, 0x8189DBBC, 0x3956C25B, 0xF348B538,
      0x59F111F1, 0xB605D019, 0x923F82A4, 0xAF194F9B, 0xAB1C5ED5,
      0xDA6D8118, 0xD807AA98, 0xA3030242, 0x12835B01, 0x45706FBE,
      0x243185BE, 0x4EE4B28C, 0x550C7DC3, 0xD5FFB4E2, 0x72BE5D74,
      0xF27B896F, 0x80DEB1FE, 0x3B1696B1, 0x9BDC06A7, 0x25C71235,
      0xC19BF174, 0xCF692694, 0xE49B69C1, 0x9EF14AD2, 0xEFBE4786,
      0x384F25E3, 0x0FC19DC6, 0x8B8CD5B5, 0x240CA1CC, 0x77AC9C65,
      0x2DE92C6F, 0x592B0275, 0x4A7484AA, 0x6EA6E483, 0x5CB0A9DC,
      0xBD41FBD4, 0x76F988DA, 0x831153B5, 0x983E5152, 0xEE66DFAB,
      0xA831C66D, 0x2DB43210, 0xB00327C8, 0x98FB213F, 0xBF597FC7,
      0xBEEF0EE4, 0xC6E00BF3, 0x3DA88FC2, 0xD5A79147, 0x930AA725,
      0x06CA6351, 0xE003826F, 0x14292967, 0x0A0E6E70, 0x27B70A85,
      0x46D22FFC, 0x2E1B2138, 0x5C26C926, 0x4D2C6DFC, 0x5AC42AED,
      0x53380D13, 0x9D95B3DF, 0x650A7354, 0x8BAF63DE, 0x766A0ABB,
      0x3C77B2A8, 0x81C2C92E, 0x47EDAEE6, 0x92722C85, 0x1482353B,
      0xA2BFE8A1, 0x4CF10364, 0xA81A664B, 0xBC423001, 0xC24B8B70,
      0xD0F89791, 0xC76C51A3, 0x0654BE30, 0xD192E819, 0xD6EF5218,
      0xD6990624, 0x5565A910, 0xF40E3585, 0x5771202A, 0x106AA070,

/**SHA384_512ProcessMessageBlock**記述: * このヘルパー機能はMessage_Blockアレイに格納された*メッセージの次の1024ビットを処理するでしょう。 * * パラメタ: * 文脈: [コネ/アウト] ***をアップデートするSHA文脈は戻ります: * 何でもない。 * * コメント: * それらが公表で使用される*名であったので、このコードの変数名の多く(特に*ただ一つのキャラクタ名)が使用されました。 * * */静的な空のSHA384_512ProcessMessageBlock(SHA512Context*文脈)、/*定数は中でFIPS-180-2、セクション4.2を定義しました; 3*/#ifdef USE_32BIT唯一の_の静的なconst uint32_t K80*2=、0x428A2F98、0xD728AE22、0×71374491、0x23EF65CD、0xB5C0FBCF、0xEC4D3B2F、0xE9B5DBA5、0x8189DBBC、0x3956C25B、0xF348B538、0x59F111F1、0xB605D019、0x923F82A4、0xAF194F9B、0xAB1C5ED5、0xDA6D8118、0xD807AA98、0xA3030242、0x12835B01、0x45706FBE、0x243185BE、0x4EE4B28C、0x550C7DC3、0xD5FFB4E2、0x72BE5D74、0xF27B896F、0x80DEB1FE、0x3B1696B1、0x9BDC06A7、0x25C71235、0xC19BF174、0xCF692694、0xE49B69C1; 0x9EF14AD2、0xEFBE4786、0x384F25E3、0x0FC19DC6、0x8B8CD5B5、0x240CA1CC、0x77AC9C65、0x2DE92C6F、0x592B0275、0x4A7484AA、0x6EA6E483、0x5CB0A9DC、0xBD41FBD4、0x76F988DA、0x831153B5、0x983E5152、0xEE66DFAB、0xA831C66D、0x2DB43210、0xB00327C8、0x98FB213F、0xBF597FC7、0xBEEF0EE4、0xC6E00BF3、0x3DA88FC2、0xD5A79147、0x930AA725、0x06CA6351、0xE003826F、0×14292967、0x0A0E6E70、0x27B70A85、0x46D22FFC、0x2E1B2138、0x5C26C926、0x4D2C6DFC、0x5AC42AED、0×53380D13、0x9D95B3DF、0x650A7354、0x8BAF63DE、0x766A0ABB、0x3C77B2A8、0x81C2C92E、0x47EDAEE6、0x92722C85、0x1482353B、0xA2BFE8A1、0x4CF10364、0xA81A664B、0xBC423001、0xC24B8B70、0xD0F89791、0xC76C51A3、0x0654BE30、0xD192E819、0xD6EF5218、0xD6990624、0x5565A910、0xF40E3585、0x5771202A、0x106AA070

Eastlake 3rd & Hansen        Informational                     [Page 60]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[60ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

      0x32BBD1B8, 0x19A4C116, 0xB8D2D0C8, 0x1E376C08, 0x5141AB53,
      0x2748774C, 0xDF8EEB99, 0x34B0BCB5, 0xE19B48A8, 0x391C0CB3,
      0xC5C95A63, 0x4ED8AA4A, 0xE3418ACB, 0x5B9CCA4F, 0x7763E373,
      0x682E6FF3, 0xD6B2B8A3, 0x748F82EE, 0x5DEFB2FC, 0x78A5636F,
      0x43172F60, 0x84C87814, 0xA1F0AB72, 0x8CC70208, 0x1A6439EC,
      0x90BEFFFA, 0x23631E28, 0xA4506CEB, 0xDE82BDE9, 0xBEF9A3F7,
      0xB2C67915, 0xC67178F2, 0xE372532B, 0xCA273ECE, 0xEA26619C,
      0xD186B8C7, 0x21C0C207, 0xEADA7DD6, 0xCDE0EB1E, 0xF57D4F7F,
      0xEE6ED178, 0x06F067AA, 0x72176FBA, 0x0A637DC5, 0xA2C898A6,
      0x113F9804, 0xBEF90DAE, 0x1B710B35, 0x131C471B, 0x28DB77F5,
      0x23047D84, 0x32CAAB7B, 0x40C72493, 0x3C9EBE0A, 0x15C9BEBC,
      0x431D67C4, 0x9C100D4C, 0x4CC5D4BE, 0xCB3E42B6, 0x597F299C,
      0xFC657E2A, 0x5FCB6FAB, 0x3AD6FAEC, 0x6C44198C, 0x4A475817
  };
  int     t, t2, t8;                  /* Loop counter */
  uint32_t  temp1[2], temp2[2],       /* Temporary word values */
        temp3[2], temp4[2], temp5[2];
  uint32_t  W[2*80];                  /* Word sequence */
  uint32_t  A[2], B[2], C[2], D[2],   /* Word buffers */
        E[2], F[2], G[2], H[2];

0x32BBD1B8、0x19A4C116、0xB8D2D0C8、0x1E376C08、0x5141AB53、0x2748774C、0xDF8EEB99、0x34B0BCB5、0xE19B48A8、0x391C0CB3、0xC5C95A63、0x4ED8AA4A、0xE3418ACB、0x5B9CCA4F、0x7763E373、0x682E6FF3、0xD6B2B8A3、0x748F82EE、0x5DEFB2FC、0x78A5636F、0x43172F60、0x84C87814、0xA1F0AB72、0x8CC70208、0x1A6439EC、0x90BEFFFA、0x23631E28、0xA4506CEB、0xDE82BDE9、0xBEF9A3F7、0xB2C67915、0xC67178F2、0xE372532B; 0xCA273ECE、0xEA26619C、0xD186B8C7、0x21C0C207、0xEADA7DD6、0xCDE0EB1E、0xF57D4F7F、0xEE6ED178、0x06F067AA、0x72176FBA、0x0A637DC5、0xA2C898A6、0x113F9804、0xBEF90DAE、0x1B710B35、0x131C471B、0x28DB77F5、0x23047D84、0x32CAAB7B、0x40C72493、0x3C9EBE0A、0x15C9BEBC、0x431D67C4、0x9C100D4C、0x4CC5D4BE、0xCB3E42B6、0x597F299C、0xFC657E2A、0x5FCB6FAB、0x3AD6FAEC、0x6C44198C、0x4A475817、。 int t、t2、t8。 _/*ループ・カウンタ*/uint32t temp1[2]、temp2[2]、/*一時的な単語値*/temp3[2]、temp4[2]、temp5[2]。 uint32_t W[2*80]。 B[2]、/*は系列*/uint32_t A[2]を言い表して、C[2]、D[2]、/*はバッファ*/E[2]、F[2]、G[2]、H[2]を言い表します。

  /* Initialize the first 16 words in the array W */
  for (t = t2 = t8 = 0; t < 16; t++, t8 += 8) {
    W[t2++] = ((((uint32_t)context->Message_Block[t8    ])) << 24) |
              ((((uint32_t)context->Message_Block[t8 + 1])) << 16) |
              ((((uint32_t)context->Message_Block[t8 + 2])) << 8) |
              ((((uint32_t)context->Message_Block[t8 + 3])));
    W[t2++] = ((((uint32_t)context->Message_Block[t8 + 4])) << 24) |
              ((((uint32_t)context->Message_Block[t8 + 5])) << 16) |
              ((((uint32_t)context->Message_Block[t8 + 6])) << 8) |
              ((((uint32_t)context->Message_Block[t8 + 7])));
  }

/*は(t8t=t2==0; t<16; t++、t8+=8)のためにアレイW*/の最初の16の単語を初期化します。{ Wt2++=((((uint32_t)文脈->は_Blockt8を通信させます)<<24)| ((uint32_t)文脈>メッセージ_Blockt8+1))<<16)| ((((uint32_t)文脈>メッセージ_Blockt8+2))<<8)| ((uint32_t)文脈>メッセージ_Blockt8+3))); Wt2++=((((uint32_t)文脈>メッセージ_Blockt8+4))<<24)| ((((uint32_t)文脈>メッセージ_Blockt8+5)<<16)| (uint32_t)文脈>メッセージ_Blockt8+6))<<8)| ((uint32_t)文脈>メッセージ_Blockt8+7))); }

  for (t = 16; t < 80; t++, t2 += 2) {
    /* W[t] = SHA512_sigma1(W[t-2]) + W[t-7] +
      SHA512_sigma0(W[t-15]) + W[t-16]; */
    uint32_t *Wt2 = &W[t2-2*2];
    uint32_t *Wt7 = &W[t2-7*2];
    uint32_t *Wt15 = &W[t2-15*2];
    uint32_t *Wt16 = &W[t2-16*2];
    SHA512_sigma1(Wt2, temp1);
    SHA512_ADD(temp1, Wt7, temp2);
    SHA512_sigma0(Wt15, temp1);
    SHA512_ADD(temp1, Wt16, temp3);
    SHA512_ADD(temp2, temp3, &W[t2]);
  }

(t=16; t<80; t++、t2+=2)のために{ /* W[t] = SHA512_sigma1(W[t-2]) + W[t-7] + SHA512_sigma0(W[t-15]) + W[t-16]; */ uint32_t *Wt2 = &W[t2-2*2]; uint32_t *Wt7 = &W[t2-7*2]; uint32_t *Wt15 = &W[t2-15*2]; uint32_t *Wt16 = &W[t2-16*2]; SHA512_sigma1(Wt2, temp1); SHA512_ADD(temp1, Wt7, temp2); SHA512_sigma0(Wt15, temp1); SHA512_ADD(temp1, Wt16, temp3); SHA512_ADD(temp2, temp3, &W[t2]); }

  A[0] = context->Intermediate_Hash[0];

A[0]は文脈->中間的な_細切れ肉料理[0]と等しいです。

Eastlake 3rd & Hansen        Informational                     [Page 61]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[61ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

  A[1] = context->Intermediate_Hash[1];
  B[0] = context->Intermediate_Hash[2];
  B[1] = context->Intermediate_Hash[3];
  C[0] = context->Intermediate_Hash[4];
  C[1] = context->Intermediate_Hash[5];
  D[0] = context->Intermediate_Hash[6];
  D[1] = context->Intermediate_Hash[7];
  E[0] = context->Intermediate_Hash[8];
  E[1] = context->Intermediate_Hash[9];
  F[0] = context->Intermediate_Hash[10];
  F[1] = context->Intermediate_Hash[11];
  G[0] = context->Intermediate_Hash[12];
  G[1] = context->Intermediate_Hash[13];
  H[0] = context->Intermediate_Hash[14];
  H[1] = context->Intermediate_Hash[15];

A[1]は文脈->中間的な_細切れ肉料理[1]と等しいです。 B[0]は文脈->中間的な_細切れ肉料理[2]と等しいです。 B[1]は文脈->中間的な_細切れ肉料理[3]と等しいです。 C[0]は文脈->中間的な_細切れ肉料理[4]と等しいです。 C[1]は文脈->中間的な_細切れ肉料理[5]と等しいです。 D[0]は文脈->中間的な_細切れ肉料理[6]と等しいです。 D[1]は文脈->中間的な_細切れ肉料理[7]と等しいです。 E[0]は文脈->中間的な_細切れ肉料理[8]と等しいです。 E[1]は文脈->中間的な_細切れ肉料理[9]と等しいです。 F[0]は文脈->中間的な_細切れ肉料理[10]と等しいです。 F[1]は文脈->中間的な_細切れ肉料理[11]と等しいです。 G[0]は文脈->中間的な_細切れ肉料理[12]と等しいです。 G[1]は文脈->中間的な_細切れ肉料理[13]と等しいです。 H[0]は文脈->中間的な_細切れ肉料理[14]と等しいです。 H[1]は文脈->中間的な_細切れ肉料理[15]と等しいです。

  for (t = t2 = 0; t < 80; t++, t2 += 2) {
    /*
     * temp1 = H + SHA512_SIGMA1(E) + SHA_Ch(E,F,G) + K[t] + W[t];
     */
    SHA512_SIGMA1(E,temp1);
    SHA512_ADD(H, temp1, temp2);
    SHA_Ch(E,F,G,temp3);
    SHA512_ADD(temp2, temp3, temp4);
    SHA512_ADD(&K[t2], &W[t2], temp5);
    SHA512_ADD(temp4, temp5, temp1);
    /*
     * temp2 = SHA512_SIGMA0(A) + SHA_Maj(A,B,C);
     */
    SHA512_SIGMA0(A,temp3);
    SHA_Maj(A,B,C,temp4);
    SHA512_ADD(temp3, temp4, temp2);
    H[0] = G[0]; H[1] = G[1];
    G[0] = F[0]; G[1] = F[1];
    F[0] = E[0]; F[1] = E[1];
    SHA512_ADD(D, temp1, E);
    D[0] = C[0]; D[1] = C[1];
    C[0] = B[0]; C[1] = B[1];
    B[0] = A[0]; B[1] = A[1];
    SHA512_ADD(temp1, temp2, A);
  }

(t2t==0; t<80; t++、t2+=2)のために{ wt..等しい..マイ; }

  SHA512_ADDTO2(&context->Intermediate_Hash[0], A);
  SHA512_ADDTO2(&context->Intermediate_Hash[2], B);
  SHA512_ADDTO2(&context->Intermediate_Hash[4], C);
  SHA512_ADDTO2(&context->Intermediate_Hash[6], D);
  SHA512_ADDTO2(&context->Intermediate_Hash[8], E);
  SHA512_ADDTO2(&context->Intermediate_Hash[10], F);

SHA512_ADDTO2、(文脈->中間的な_細切れ肉料理[0]、a)。 SHA512_ADDTO2(文脈->中間的な_細切れ肉料理[2]、B)。 SHA512_ADDTO2(文脈->中間的な_細切れ肉料理[4]、C)。 SHA512_ADDTO2(文脈->中間的な_細切れ肉料理[6]、D)。 SHA512_ADDTO2(文脈->中間的な_細切れ肉料理[8]、E)。 SHA512_ADDTO2(文脈->中間的な_細切れ肉料理[10]、F)。

Eastlake 3rd & Hansen        Informational                     [Page 62]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

イーストレーク3番目とハンセン情報[62ページ]のRFC4634SHAsとHMAC-SHAs2006年7月

  SHA512_ADDTO2(&context->Intermediate_Hash[12], G);
  SHA512_ADDTO2(&context->Intermediate_Hash[14], H);

SHA512_ADDTO2(文脈->中間的な_細切れ肉料理[12]、G)。 SHA512_ADDTO2(文脈->中間的な_細切れ肉料理[14]、H)。

#else /* !USE_32BIT_ONLY */
  static const uint64_t K[80] = {
      0x428A2F98D728AE22ll, 0x7137449123EF65CDll, 0xB5C0FBCFEC4D3B2Fll,
      0xE9B5DBA58189DBBCll, 0x3956C25BF348B538ll, 0x59F111F1B605D019ll,
      0x923F82A4AF194F9Bll, 0xAB1C5ED5DA6D8118ll, 0xD807AA98A3030242ll,
      0x12835B0145706FBEll, 0x243185BE4EE4B28Cll, 0x550C7DC3D5FFB4E2ll,
      0x72BE5D74F27B896Fll, 0x80DEB1FE3B1696B1ll, 0x9BDC06A725C71235ll,
      0xC19BF174CF692694ll, 0xE49B69C19EF14AD2ll, 0xEFBE4786384F25E3ll,
      0x0FC19DC68B8CD5B5ll, 0x240CA1CC77AC9C65ll, 0x2DE92C6F592B0275ll,
      0x4A7484AA6EA6E483ll, 0x5CB0A9DCBD41FBD4ll, 0x76F988DA831153B5ll,
      0x983E5152EE66DFABll, 0xA831C66D2DB43210ll, 0xB00327C898FB213Fll,
      0xBF597FC7BEEF0EE4ll, 0xC6E00BF33DA88FC2ll, 0xD5A79147930AA725ll,
      0x06CA6351E003826Fll, 0x142929670A0E6E70ll, 0x27B70A8546D22FFCll,
      0x2E1B21385C26C926ll, 0x4D2C6DFC5AC42AEDll, 0x53380D139D95B3DFll,
      0x650A73548BAF63DEll, 0x766A0ABB3C77B2A8ll, 0x81C2C92E47EDAEE6ll,
      0x92722C851482353Bll, 0xA2BFE8A14CF10364ll, 0xA81A664BBC423001ll,
      0xC24B8B70D0F89791ll, 0xC76C51A30654BE30ll, 0xD192E819D6EF5218ll,
      0xD69906245565A910ll, 0xF40E35855771202All, 0x106AA07032BBD1B8ll,
      0x19A4C116B8D2D0C8ll, 0x1E376C085141AB53ll, 0x2748774CDF8EEB99ll,
      0x34B0BCB5E19B48A8ll, 0x391C0CB3C5C95A63ll, 0x4ED8AA4AE3418ACBll,
      0x5B9CCA4F7763E373ll, 0x682E6FF3D6B2B8A3ll, 0x748F82EE5DEFB2FCll,
      0x78A5636F43172F60ll, 0x84C87814A1F0AB72ll, 0x8CC702081A6439ECll,
      0x90BEFFFA23631E28ll, 0xA4506CEBDE82BDE9ll, 0xBEF9A3F7B2C67915ll,
      0xC67178F2E372532Bll, 0xCA273ECEEA26619Cll, 0xD186B8C721C0C207ll,
      0xEADA7DD6CDE0EB1Ell, 0xF57D4F7FEE6ED178ll, 0x06F067AA72176FBAll,
      0x0A637DC5A2C898A6ll, 0x113F9804BEF90DAEll, 0x1B710B35131C471Bll,
      0x28DB77F523047D84ll, 0x32CAAB7B40C72493ll, 0x3C9EBE0A15C9BEBCll,
      0x431D67C49C100D4Cll, 0x4CC5D4BECB3E42B6ll, 0x597F299CFC657E2All,
      0x5FCB6FAB3AD6FAECll, 0x6C44198C4A475817ll
  };
  int        t, t8;                   /* Loop counter */
  uint64_t   temp1, temp2;            /* Temporary word value */
  uint64_t   W[80];                   /* Word sequence */
  uint64_t   A, B, C, D, E, F, G, H;  /* Word buffers */

#ほかの/*!USE_32BIT唯一の_*/静電気const uint64_t K80が等しい、0x428A2F98D728AE22ll、0x7137449123EF65CDll、0xB5C0FBCFEC4D3B2Fll、0xE9B5DBA58189DBBCll、0x3956C25BF348B538ll、0x59F111F1B605D019ll、0x923F82A4AF194F9Bll、0xAB1C5ED5DA6D8118ll、0xD807AA98A3030242ll; 0x12835B0145706FBEll、0x243185BE4EE4B28Cll、0x550C7DC3D5FFB4E2ll、0x72BE5D74F27B896Fll、0x80DEB1FE3B1696B1ll、0x9BDC06A725C71235ll、0xC19BF174CF692694ll、0xE49B69C19EF14AD2ll、0xEFBE4786384F25E3ll、0x0FC19DC68B8CD5B5ll、0x240CA1CC77AC9C65ll、0x2DE92C6F592B0275ll; 0x4A7484AA6EA6E483ll、0x5CB0A9DCBD41FBD4ll、0x76F988DA831153B5ll、0x983E5152EE66DFABll、0xA831C66D2DB43210ll、0xB00327C898FB213Fll、0xBF597FC7BEEF0EE4ll、0xC6E00BF33DA88FC2ll、0xD5A79147930AA725ll、0x06CA6351E003826Fll、0x142929670A0E6E70ll、0x27B70A8546D22FFCll、0x2E1B21385C26C926ll、0x4D2C6DFC5AC42AEDll、0x53380D139D95B3DFll、0x650A73548BAF63DEll、0x766A0ABB3C77B2A8ll、0x81C2C92E47EDAEE6ll、0x92722C851482353Bll、0xA2BFE8A14CF10364ll、0xA81A664BBC423001ll、0xC24B8B70D0F89791ll、0xC76C51A30654BE30ll、0xD192E819D6EF5218ll、0xD69906245565A910ll、0xF40E35855771202All、0x106AA07032BBD1B8ll、0x19A4C116B8D2D0C8ll、0x1E376C085141AB53ll、0x2748774CDF8EEB99ll、0x34B0BCB5E19B48A8ll、0x391C0CB3C5C95A63ll、0x4ED8AA4AE3418ACBll、0x5B9CCA4F7763E373ll、0x682E6FF3D6B2B8A3ll、0x748F82EE5DEFB2FCll、0x78A5636F43172F60ll、0x84C87814A1F0AB72ll、0x8CC702081A6439ECll、0x90BEFFFA23631E28ll、0xA4506CEBDE82BDE9ll; 0xBEF9A3F7B2C67915ll、0xC67178F2E372532Bll、0xCA273ECEEA26619Cll、0xD186B8C721C0C207ll、0xEADA7DD6CDE0EB1Ell、0xF57D4F7FEE6ED178ll、0x06F067AA72176FBAll、0x0A637DC5A2C898A6ll、0x113F9804BEF90DAEll、0x1B710B35131C471Bll、0x28DB77F523047D84ll、0x32CAAB7B40C72493ll、0x3C9EBE0A15C9BEBCll、0x431D67C49C100D4Cll、0x4CC5D4BECB3E42B6ll、0x597F299CFC657E2All、0x5FCB6FAB3AD6FAECll、0x6C44198C4A475817ll、。 int t、t8。 _/*ループ・カウンタ*/uint64t temp1、temp2。 /*一時的な単語値の*/uint64_t W[80]。 H、/*は系列*/uint64_t A、B、C、D、E、F、Gを言い表します。 /*はバッファ*/を言い表します。

  /*
   * Initialize the first 16 words in the array W
   */
  for (t = t8 = 0; t < 16; t++, t8 += 8)
    W[t] = ((uint64_t)(context->Message_Block[t8  ]) << 56) |
           ((uint64_t)(context->Message_Block[t8 + 1]) << 48) |
           ((uint64_t)(context->Message_Block[t8 + 2]) << 40) |
           ((uint64_t)(context->Message_Block[t8 + 3]) << 32) |
           ((uint64_t)(context->Message_Block[t8 + 4]) << 24) |
           ((uint64_t)(context->Message_Block[t8 + 5]) << 16) |

/**が(tはt8=0; t<16; t++と等しいです、t8+=8)W[t]=(uint64_t)のためにアレイW*/の最初の16の単語を初期化する、(文脈、-、>Message_Block[t8)<<56)| (uint64_t)(メッセージ_が妨げる文脈->[t8+1])<<48) | (uint64_t)(メッセージ_が妨げる文脈->[t8+2])<<40) | (uint64_t)(メッセージ_が妨げる文脈->[t8+3])<<32) | (uint64_t)(メッセージ_が妨げる文脈->[t8+4])<<24) | (uint64_t)(メッセージ_が妨げる文脈->[t8+5])<<16) |

Eastlake 3rd & Hansen        Informational                     [Page 63]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 63] RFC 4634 SHAs and HMAC-SHAs July 2006

           ((uint64_t)(context->Message_Block[t8 + 6]) << 8) |
           ((uint64_t)(context->Message_Block[t8 + 7]));

((uint64_t)(context->Message_Block[t8 + 6]) << 8) | ((uint64_t)(context->Message_Block[t8 + 7]));

  for (t = 16; t < 80; t++)
    W[t] = SHA512_sigma1(W[t-2]) + W[t-7] +
        SHA512_sigma0(W[t-15]) + W[t-16];

for (t = 16; t < 80; t++) W[t] = SHA512_sigma1(W[t-2]) + W[t-7] + SHA512_sigma0(W[t-15]) + W[t-16];

  A = context->Intermediate_Hash[0];
  B = context->Intermediate_Hash[1];
  C = context->Intermediate_Hash[2];
  D = context->Intermediate_Hash[3];
  E = context->Intermediate_Hash[4];
  F = context->Intermediate_Hash[5];
  G = context->Intermediate_Hash[6];
  H = context->Intermediate_Hash[7];

A = context->Intermediate_Hash[0]; B = context->Intermediate_Hash[1]; C = context->Intermediate_Hash[2]; D = context->Intermediate_Hash[3]; E = context->Intermediate_Hash[4]; F = context->Intermediate_Hash[5]; G = context->Intermediate_Hash[6]; H = context->Intermediate_Hash[7];

  for (t = 0; t < 80; t++) {
    temp1 = H + SHA512_SIGMA1(E) + SHA_Ch(E,F,G) + K[t] + W[t];
    temp2 = SHA512_SIGMA0(A) + SHA_Maj(A,B,C);
    H = G;
    G = F;
    F = E;
    E = D + temp1;
    D = C;
    C = B;
    B = A;
    A = temp1 + temp2;
  }

for (t = 0; t < 80; t++) { temp1 = H + SHA512_SIGMA1(E) + SHA_Ch(E,F,G) + K[t] + W[t]; temp2 = SHA512_SIGMA0(A) + SHA_Maj(A,B,C); H = G; G = F; F = E; E = D + temp1; D = C; C = B; B = A; A = temp1 + temp2; }

  context->Intermediate_Hash[0] += A;
  context->Intermediate_Hash[1] += B;
  context->Intermediate_Hash[2] += C;
  context->Intermediate_Hash[3] += D;
  context->Intermediate_Hash[4] += E;
  context->Intermediate_Hash[5] += F;
  context->Intermediate_Hash[6] += G;
  context->Intermediate_Hash[7] += H;
#endif /* USE_32BIT_ONLY */

context->Intermediate_Hash[0] += A; context->Intermediate_Hash[1] += B; context->Intermediate_Hash[2] += C; context->Intermediate_Hash[3] += D; context->Intermediate_Hash[4] += E; context->Intermediate_Hash[5] += F; context->Intermediate_Hash[6] += G; context->Intermediate_Hash[7] += H; #endif /* USE_32BIT_ONLY */

  context->Message_Block_Index = 0;
}

context->Message_Block_Index = 0; }

/*
 * SHA384_512Reset
 *
 * Description:
 *   This helper function will initialize the SHA512Context in
 *   preparation for computing a new SHA384 or SHA512 message

/* * SHA384_512Reset * * Description: * This helper function will initialize the SHA512Context in * preparation for computing a new SHA384 or SHA512 message

Eastlake 3rd & Hansen        Informational                     [Page 64]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 64] RFC 4634 SHAs and HMAC-SHAs July 2006

 *   digest.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to reset.
 *   H0
 *     The initial hash value to use.
 *
 * Returns:
 *   sha Error Code.
 *
 */
#ifdef USE_32BIT_ONLY
static int SHA384_512Reset(SHA512Context *context, uint32_t H0[])
#else /* !USE_32BIT_ONLY */
static int SHA384_512Reset(SHA512Context *context, uint64_t H0[])
#endif /* USE_32BIT_ONLY */
{
  int i;
  if (!context)
    return shaNull;

* digest. * * Parameters: * context: [in/out] * The context to reset. * H0 * The initial hash value to use. * * Returns: * sha Error Code. * */ #ifdef USE_32BIT_ONLY static int SHA384_512Reset(SHA512Context *context, uint32_t H0[]) #else /* !USE_32BIT_ONLY */ static int SHA384_512Reset(SHA512Context *context, uint64_t H0[]) #endif /* USE_32BIT_ONLY */ { int i; if (!context) return shaNull;

  context->Message_Block_Index = 0;

context->Message_Block_Index = 0;

#ifdef USE_32BIT_ONLY
  context->Length[0] = context->Length[1] = 0;
  context->Length[2] = context->Length[3] = 0;

#ifdef USE_32BIT_ONLY context->Length[0] = context->Length[1] = 0; context->Length[2] = context->Length[3] = 0;

  for (i = 0; i < SHA512HashSize/4; i++)
    context->Intermediate_Hash[i] = H0[i];
#else /* !USE_32BIT_ONLY */
  context->Length_High = context->Length_Low = 0;

for (i = 0; i < SHA512HashSize/4; i++) context->Intermediate_Hash[i] = H0[i]; #else /* !USE_32BIT_ONLY */ context->Length_High = context->Length_Low = 0;

  for (i = 0; i < SHA512HashSize/8; i++)
    context->Intermediate_Hash[i] = H0[i];
#endif /* USE_32BIT_ONLY */

for (i = 0; i < SHA512HashSize/8; i++) context->Intermediate_Hash[i] = H0[i]; #endif /* USE_32BIT_ONLY */

  context->Computed = 0;
  context->Corrupted = 0;

context->Computed = 0; context->Corrupted = 0;

  return shaSuccess;
}

return shaSuccess; }

/*
 * SHA384_512ResultN
 *
 * Description:
 *   This helper function will return the 384-bit or 512-bit message

/* * SHA384_512ResultN * * Description: * This helper function will return the 384-bit or 512-bit message

Eastlake 3rd & Hansen        Informational                     [Page 65]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 65] RFC 4634 SHAs and HMAC-SHAs July 2006

 *   digest into the Message_Digest array provided by the caller.
 *   NOTE: The first octet of hash is stored in the 0th element,
 *      the last octet of hash in the 48th/64th element.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to use to calculate the SHA hash.
 *   Message_Digest: [out]
 *     Where the digest is returned.
 *   HashSize: [in]
 *     The size of the hash, either 48 or 64.
 *
 * Returns:
 *   sha Error Code.
 *
 */
static int SHA384_512ResultN(SHA512Context *context,
    uint8_t Message_Digest[], int HashSize)
{
  int i;

* digest into the Message_Digest array provided by the caller. * NOTE: The first octet of hash is stored in the 0th element, * the last octet of hash in the 48th/64th element. * * Parameters: * context: [in/out] * The context to use to calculate the SHA hash. * Message_Digest: [out] * Where the digest is returned. * HashSize: [in] * The size of the hash, either 48 or 64. * * Returns: * sha Error Code. * */ static int SHA384_512ResultN(SHA512Context *context, uint8_t Message_Digest[], int HashSize) { int i;

#ifdef USE_32BIT_ONLY
  int i2;
#endif /* USE_32BIT_ONLY */

#ifdef USE_32BIT_ONLY int i2; #endif /* USE_32BIT_ONLY */

  if (!context || !Message_Digest)
    return shaNull;

if (!context || !Message_Digest) return shaNull;

  if (context->Corrupted)
    return context->Corrupted;

if (context->Corrupted) return context->Corrupted;

  if (!context->Computed)
    SHA384_512Finalize(context, 0x80);

if (!context->Computed) SHA384_512Finalize(context, 0x80);

#ifdef USE_32BIT_ONLY
  for (i = i2 = 0; i < HashSize; ) {
    Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2]>>24);
    Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2]>>16);
    Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2]>>8);
    Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2++]);
    Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2]>>24);
    Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2]>>16);
    Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2]>>8);
    Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2++]);
  }
#else /* !USE_32BIT_ONLY */
  for (i = 0; i < HashSize; ++i)
    Message_Digest[i] = (uint8_t)

#ifdef USE_32BIT_ONLY for (i = i2 = 0; i < HashSize; ) { Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2]>>24); Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2]>>16); Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2]>>8); Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2++]); Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2]>>24); Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2]>>16); Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2]>>8); Message_Digest[i++]=(uint8_t)(context->Intermediate_Hash[i2++]); } #else /* !USE_32BIT_ONLY */ for (i = 0; i < HashSize; ++i) Message_Digest[i] = (uint8_t)

Eastlake 3rd & Hansen        Informational                     [Page 66]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 66] RFC 4634 SHAs and HMAC-SHAs July 2006

      (context->Intermediate_Hash[i>>3] >> 8 * ( 7 - ( i % 8 ) ));
#endif /* USE_32BIT_ONLY */

(context->Intermediate_Hash[i>>3] >> 8 * ( 7 - ( i % 8 ) )); #endif /* USE_32BIT_ONLY */

  return shaSuccess;
}

return shaSuccess; }

8.2.4.  usha.c

8.2.4. usha.c

/**************************** usha.c ****************************/
/******************** See RFC 4634 for details ******************/
/*
 *  Description:
 *     This file implements a unified interface to the SHA algorithms.
 */

/**************************** usha.c ****************************/ /******************** See RFC 4634 for details ******************/ /* * Description: * This file implements a unified interface to the SHA algorithms. */

#include "sha.h"

#include "sha.h"

/*
 *  USHAReset
 *
 *  Description:
 *      This function will initialize the SHA Context in preparation
 *      for computing a new SHA message digest.
 *
 *  Parameters:
 *      context: [in/out]
 *          The context to reset.
 *      whichSha: [in]
 *          Selects which SHA reset to call
 *
 *  Returns:
 *      sha Error Code.
 *
 */
int USHAReset(USHAContext *ctx, enum SHAversion whichSha)
{
  if (ctx) {
    ctx->whichSha = whichSha;
    switch (whichSha) {
      case SHA1:   return SHA1Reset((SHA1Context*)&ctx->ctx);
      case SHA224: return SHA224Reset((SHA224Context*)&ctx->ctx);
      case SHA256: return SHA256Reset((SHA256Context*)&ctx->ctx);
      case SHA384: return SHA384Reset((SHA384Context*)&ctx->ctx);
      case SHA512: return SHA512Reset((SHA512Context*)&ctx->ctx);
      default: return shaBadParam;
    }
  } else {
    return shaNull;

/* * USHAReset * * Description: * This function will initialize the SHA Context in preparation * for computing a new SHA message digest. * * Parameters: * context: [in/out] * The context to reset. * whichSha: [in] * Selects which SHA reset to call * * Returns: * sha Error Code. * */ int USHAReset(USHAContext *ctx, enum SHAversion whichSha) { if (ctx) { ctx->whichSha = whichSha; switch (whichSha) { case SHA1: return SHA1Reset((SHA1Context*)&ctx->ctx); case SHA224: return SHA224Reset((SHA224Context*)&ctx->ctx); case SHA256: return SHA256Reset((SHA256Context*)&ctx->ctx); case SHA384: return SHA384Reset((SHA384Context*)&ctx->ctx); case SHA512: return SHA512Reset((SHA512Context*)&ctx->ctx); default: return shaBadParam; } } else { return shaNull;

Eastlake 3rd & Hansen        Informational                     [Page 67]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 67] RFC 4634 SHAs and HMAC-SHAs July 2006

  }
}

} }

/*
 *  USHAInput
 *
 *  Description:
 *      This function accepts an array of octets as the next portion
 *      of the message.
 *
 *  Parameters:
 *      context: [in/out]
 *          The SHA context to update
 *      message_array: [in]
 *          An array of characters representing the next portion of
 *          the message.
 *      length: [in]
 *          The length of the message in message_array
 *
 *  Returns:
 *      sha Error Code.
 *
 */
int USHAInput(USHAContext *ctx,
              const uint8_t *bytes, unsigned int bytecount)
{
  if (ctx) {
    switch (ctx->whichSha) {
      case SHA1:
        return SHA1Input((SHA1Context*)&ctx->ctx, bytes, bytecount);
      case SHA224:
        return SHA224Input((SHA224Context*)&ctx->ctx, bytes,
            bytecount);
      case SHA256:
        return SHA256Input((SHA256Context*)&ctx->ctx, bytes,
            bytecount);
      case SHA384:
        return SHA384Input((SHA384Context*)&ctx->ctx, bytes,
            bytecount);
      case SHA512:
        return SHA512Input((SHA512Context*)&ctx->ctx, bytes,
            bytecount);
      default: return shaBadParam;
    }
  } else {
    return shaNull;
  }
}

/* * USHAInput * * Description: * This function accepts an array of octets as the next portion * of the message. * * Parameters: * context: [in/out] * The SHA context to update * message_array: [in] * An array of characters representing the next portion of * the message. * length: [in] * The length of the message in message_array * * Returns: * sha Error Code. * */ int USHAInput(USHAContext *ctx, const uint8_t *bytes, unsigned int bytecount) { if (ctx) { switch (ctx->whichSha) { case SHA1: return SHA1Input((SHA1Context*)&ctx->ctx, bytes, bytecount); case SHA224: return SHA224Input((SHA224Context*)&ctx->ctx, bytes, bytecount); case SHA256: return SHA256Input((SHA256Context*)&ctx->ctx, bytes, bytecount); case SHA384: return SHA384Input((SHA384Context*)&ctx->ctx, bytes, bytecount); case SHA512: return SHA512Input((SHA512Context*)&ctx->ctx, bytes, bytecount); default: return shaBadParam; } } else { return shaNull; } }

Eastlake 3rd & Hansen        Informational                     [Page 68]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 68] RFC 4634 SHAs and HMAC-SHAs July 2006

/*
 * USHAFinalBits
 *
 * Description:
 *   This function will add in any final bits of the message.
 *
 * Parameters:
 *   context: [in/out]
 *     The SHA context to update
 *   message_bits: [in]
 *     The final bits of the message, in the upper portion of the
 *     byte. (Use 0b###00000 instead of 0b00000### to input the
 *     three bits ###.)
 *   length: [in]
 *     The number of bits in message_bits, between 1 and 7.
 *
 * Returns:
 *   sha Error Code.
 */
int USHAFinalBits(USHAContext *ctx,
                  const uint8_t bits, unsigned int bitcount)
{
  if (ctx) {
    switch (ctx->whichSha) {
      case SHA1:
        return SHA1FinalBits((SHA1Context*)&ctx->ctx, bits, bitcount);
      case SHA224:
        return SHA224FinalBits((SHA224Context*)&ctx->ctx, bits,
            bitcount);
      case SHA256:
        return SHA256FinalBits((SHA256Context*)&ctx->ctx, bits,
            bitcount);
      case SHA384:
        return SHA384FinalBits((SHA384Context*)&ctx->ctx, bits,
            bitcount);
      case SHA512:
        return SHA512FinalBits((SHA512Context*)&ctx->ctx, bits,
            bitcount);
      default: return shaBadParam;
    }
  } else {
    return shaNull;
  }
}

/* * USHAFinalBits * * Description: * This function will add in any final bits of the message. * * Parameters: * context: [in/out] * The SHA context to update * message_bits: [in] * The final bits of the message, in the upper portion of the * byte. (Use 0b###00000 instead of 0b00000### to input the * three bits ###.) * length: [in] * The number of bits in message_bits, between 1 and 7. * * Returns: * sha Error Code. */ int USHAFinalBits(USHAContext *ctx, const uint8_t bits, unsigned int bitcount) { if (ctx) { switch (ctx->whichSha) { case SHA1: return SHA1FinalBits((SHA1Context*)&ctx->ctx, bits, bitcount); case SHA224: return SHA224FinalBits((SHA224Context*)&ctx->ctx, bits, bitcount); case SHA256: return SHA256FinalBits((SHA256Context*)&ctx->ctx, bits, bitcount); case SHA384: return SHA384FinalBits((SHA384Context*)&ctx->ctx, bits, bitcount); case SHA512: return SHA512FinalBits((SHA512Context*)&ctx->ctx, bits, bitcount); default: return shaBadParam; } } else { return shaNull; } }

/*
 * USHAResult
 *

/* * USHAResult *

Eastlake 3rd & Hansen        Informational                     [Page 69]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 69] RFC 4634 SHAs and HMAC-SHAs July 2006

 * Description:
 *   This function will return the 160-bit message digest into the
 *   Message_Digest array provided by the caller.
 *   NOTE: The first octet of hash is stored in the 0th element,
 *      the last octet of hash in the 19th element.
 *
 * Parameters:
 *   context: [in/out]
 *     The context to use to calculate the SHA-1 hash.
 *   Message_Digest: [out]
 *     Where the digest is returned.
 *
 * Returns:
 *   sha Error Code.
 *
 */
int USHAResult(USHAContext *ctx,
               uint8_t Message_Digest[USHAMaxHashSize])
{
  if (ctx) {
    switch (ctx->whichSha) {
      case SHA1:
        return SHA1Result((SHA1Context*)&ctx->ctx, Message_Digest);
      case SHA224:
        return SHA224Result((SHA224Context*)&ctx->ctx, Message_Digest);
      case SHA256:
        return SHA256Result((SHA256Context*)&ctx->ctx, Message_Digest);
      case SHA384:
        return SHA384Result((SHA384Context*)&ctx->ctx, Message_Digest);
      case SHA512:
        return SHA512Result((SHA512Context*)&ctx->ctx, Message_Digest);
      default: return shaBadParam;
    }
  } else {
    return shaNull;
  }
}

* Description: * This function will return the 160-bit message digest into the * Message_Digest array provided by the caller. * NOTE: The first octet of hash is stored in the 0th element, * the last octet of hash in the 19th element. * * Parameters: * context: [in/out] * The context to use to calculate the SHA-1 hash. * Message_Digest: [out] * Where the digest is returned. * * Returns: * sha Error Code. * */ int USHAResult(USHAContext *ctx, uint8_t Message_Digest[USHAMaxHashSize]) { if (ctx) { switch (ctx->whichSha) { case SHA1: return SHA1Result((SHA1Context*)&ctx->ctx, Message_Digest); case SHA224: return SHA224Result((SHA224Context*)&ctx->ctx, Message_Digest); case SHA256: return SHA256Result((SHA256Context*)&ctx->ctx, Message_Digest); case SHA384: return SHA384Result((SHA384Context*)&ctx->ctx, Message_Digest); case SHA512: return SHA512Result((SHA512Context*)&ctx->ctx, Message_Digest); default: return shaBadParam; } } else { return shaNull; } }

/*
 * USHABlockSize
 *
 * Description:
 *   This function will return the blocksize for the given SHA
 *   algorithm.
 *
 * Parameters:
 *   whichSha:
 *     which SHA algorithm to query

/* * USHABlockSize * * Description: * This function will return the blocksize for the given SHA * algorithm. * * Parameters: * whichSha: * which SHA algorithm to query

Eastlake 3rd & Hansen        Informational                     [Page 70]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 70] RFC 4634 SHAs and HMAC-SHAs July 2006

 *
 * Returns:
 *   block size
 *
 */
int USHABlockSize(enum SHAversion whichSha)
{
  switch (whichSha) {
    case SHA1:   return SHA1_Message_Block_Size;
    case SHA224: return SHA224_Message_Block_Size;
    case SHA256: return SHA256_Message_Block_Size;
    case SHA384: return SHA384_Message_Block_Size;
    default:
    case SHA512: return SHA512_Message_Block_Size;
  }
}

* * Returns: * block size * */ int USHABlockSize(enum SHAversion whichSha) { switch (whichSha) { case SHA1: return SHA1_Message_Block_Size; case SHA224: return SHA224_Message_Block_Size; case SHA256: return SHA256_Message_Block_Size; case SHA384: return SHA384_Message_Block_Size; default: case SHA512: return SHA512_Message_Block_Size; } }

/*
 * USHAHashSize
 *
 * Description:
 *   This function will return the hashsize for the given SHA
 *   algorithm.
 *
 * Parameters:
 *   whichSha:
 *     which SHA algorithm to query
 *
 * Returns:
 *   hash size
 *
 */
int USHAHashSize(enum SHAversion whichSha)
{
  switch (whichSha) {
    case SHA1:   return SHA1HashSize;
    case SHA224: return SHA224HashSize;
    case SHA256: return SHA256HashSize;
    case SHA384: return SHA384HashSize;
    default:
    case SHA512: return SHA512HashSize;
  }
}

/* * USHAHashSize * * Description: * This function will return the hashsize for the given SHA * algorithm. * * Parameters: * whichSha: * which SHA algorithm to query * * Returns: * hash size * */ int USHAHashSize(enum SHAversion whichSha) { switch (whichSha) { case SHA1: return SHA1HashSize; case SHA224: return SHA224HashSize; case SHA256: return SHA256HashSize; case SHA384: return SHA384HashSize; default: case SHA512: return SHA512HashSize; } }

/*
 * USHAHashSizeBits
 *
 * Description:

/* * USHAHashSizeBits * * Description:

Eastlake 3rd & Hansen        Informational                     [Page 71]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 71] RFC 4634 SHAs and HMAC-SHAs July 2006

 *   This function will return the hashsize for the given SHA
 *   algorithm, expressed in bits.
 *
 * Parameters:
 *   whichSha:
 *     which SHA algorithm to query
 *
 * Returns:
 *   hash size in bits
 *
 */
int USHAHashSizeBits(enum SHAversion whichSha)
{
  switch (whichSha) {
    case SHA1:   return SHA1HashSizeBits;
    case SHA224: return SHA224HashSizeBits;
    case SHA256: return SHA256HashSizeBits;
    case SHA384: return SHA384HashSizeBits;
    default:
    case SHA512: return SHA512HashSizeBits;
  }
}

* This function will return the hashsize for the given SHA * algorithm, expressed in bits. * * Parameters: * whichSha: * which SHA algorithm to query * * Returns: * hash size in bits * */ int USHAHashSizeBits(enum SHAversion whichSha) { switch (whichSha) { case SHA1: return SHA1HashSizeBits; case SHA224: return SHA224HashSizeBits; case SHA256: return SHA256HashSizeBits; case SHA384: return SHA384HashSizeBits; default: case SHA512: return SHA512HashSizeBits; } }

8.2.5.  sha-private.h

8.2.5. sha-private.h

/*************************** sha-private.h ***************************/
/********************** See RFC 4634 for details *********************/
#ifndef _SHA_PRIVATE__H
#define _SHA_PRIVATE__H
/*
 * These definitions are defined in FIPS-180-2, section 4.1.
 * Ch() and Maj() are defined identically in sections 4.1.1,
 * 4.1.2 and 4.1.3.
 *
 * The definitions used in FIPS-180-2 are as follows:
 */

/*************************** sha-private.h ***************************/ /********************** See RFC 4634 for details *********************/ #ifndef _SHA_PRIVATE__H #define _SHA_PRIVATE__H /* * These definitions are defined in FIPS-180-2, section 4.1. * Ch() and Maj() are defined identically in sections 4.1.1, * 4.1.2 and 4.1.3. * * The definitions used in FIPS-180-2 are as follows: */

#ifndef USE_MODIFIED_MACROS
#define SHA_Ch(x,y,z)        (((x) & (y)) ^ ((~(x)) & (z)))
#define SHA_Maj(x,y,z)       (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))

#ifndef USE_MODIFIED_MACROS #define SHA_Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z))) #define SHA_Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))

#else /* USE_MODIFIED_MACROS */
/*
 * The following definitions are equivalent and potentially faster.
 */

#else /* USE_MODIFIED_MACROS */ /* * The following definitions are equivalent and potentially faster. */

#define SHA_Ch(x, y, z)      (((x) & ((y) ^ (z))) ^ (z))
#define SHA_Maj(x, y, z)     (((x) & ((y) | (z))) | ((y) & (z)))

#define SHA_Ch(x, y, z) (((x) & ((y) ^ (z))) ^ (z)) #define SHA_Maj(x, y, z) (((x) & ((y) | (z))) | ((y) & (z)))

Eastlake 3rd & Hansen        Informational                     [Page 72]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 72] RFC 4634 SHAs and HMAC-SHAs July 2006

#endif /* USE_MODIFIED_MACROS */

#endif /* USE_MODIFIED_MACROS */

#define SHA_Parity(x, y, z)  ((x) ^ (y) ^ (z))

#define SHA_Parity(x, y, z) ((x) ^ (y) ^ (z))

#endif /* _SHA_PRIVATE__H */

#endif /* _SHA_PRIVATE__H */

8.3 The HMAC Code

8.3 The HMAC Code

/**************************** hmac.c ****************************/
/******************** See RFC 4634 for details ******************/
/*
 *  Description:
 *      This file implements the HMAC algorithm (Keyed-Hashing for
 *      Message Authentication, RFC2104), expressed in terms of the
 *      various SHA algorithms.
 */

/**************************** hmac.c ****************************/ /******************** See RFC 4634 for details ******************/ /* * Description: * This file implements the HMAC algorithm (Keyed-Hashing for * Message Authentication, RFC2104), expressed in terms of the * various SHA algorithms. */

#include "sha.h"

#include "sha.h"

/*
 *  hmac
 *
 *  Description:
 *      This function will compute an HMAC message digest.
 *
 *  Parameters:
 *      whichSha: [in]
 *          One of SHA1, SHA224, SHA256, SHA384, SHA512
 *      key: [in]
 *          The secret shared key.
 *      key_len: [in]
 *          The length of the secret shared key.
 *      message_array: [in]
 *          An array of characters representing the message.
 *      length: [in]
 *          The length of the message in message_array
 *      digest: [out]
 *          Where the digest is returned.
 *          NOTE: The length of the digest is determined by
 *              the value of whichSha.
 *
 *  Returns:
 *      sha Error Code.
 *
 */
int hmac(SHAversion whichSha, const unsigned char *text, int text_len,
    const unsigned char *key, int key_len,
    uint8_t digest[USHAMaxHashSize])

/* * hmac * * Description: * This function will compute an HMAC message digest. * * Parameters: * whichSha: [in] * One of SHA1, SHA224, SHA256, SHA384, SHA512 * key: [in] * The secret shared key. * key_len: [in] * The length of the secret shared key. * message_array: [in] * An array of characters representing the message. * length: [in] * The length of the message in message_array * digest: [out] * Where the digest is returned. * NOTE: The length of the digest is determined by * the value of whichSha. * * Returns: * sha Error Code. * */ int hmac(SHAversion whichSha, const unsigned char *text, int text_len, const unsigned char *key, int key_len, uint8_t digest[USHAMaxHashSize])

Eastlake 3rd & Hansen        Informational                     [Page 73]

RFC 4634                   SHAs and HMAC-SHAs                  July 2006

Eastlake 3rd & Hansen Informational [Page 73] RFC 4634 SHAs and HMAC-SHAs July 2006

{
  HMACContext ctx;
  return hmacReset(&ctx, whichSha, key, key_len) ||
         hmacInput(&ctx, text, text_len) ||
         hmacResult(&ctx, digest);
}

{ HMACContext ctx; return hmacReset(&ctx, whichSha, key, key_len) || hmacInput(&ctx, text, text_len) || hmacResult(&ctx, digest); }

一覧

 RFC 1〜100  RFC 1401〜1500  RFC 2801〜2900  RFC 4201〜4300 
 RFC 101〜200  RFC 1501〜1600  RFC 2901〜3000  RFC 4301〜4400 
 RFC 201〜300  RFC 1601〜1700  RFC 3001〜3100  RFC 4401〜4500 
 RFC 301〜400  RFC 1701〜1800  RFC 3101〜3200  RFC 4501〜4600 
 RFC 401〜500  RFC 1801〜1900  RFC 3201〜3300  RFC 4601〜4700 
 RFC 501〜600  RFC 1901〜2000  RFC 3301〜3400  RFC 4701〜4800 
 RFC 601〜700  RFC 2001〜2100  RFC 3401〜3500  RFC 4801〜4900 
 RFC 701〜800  RFC 2101〜2200  RFC 3501〜3600  RFC 4901〜5000 
 RFC 801〜900  RFC 2201〜2300  RFC 3601〜3700  RFC 5001〜5100 
 RFC 901〜1000  RFC 2301〜2400  RFC 3701〜3800  RFC 5101〜5200 
 RFC 1001〜1100  RFC 2401〜2500  RFC 3801〜3900  RFC 5201〜5300 
 RFC 1101〜1200  RFC 2501〜2600  RFC 3901〜4000  RFC 5301〜5400 
 RFC 1201〜1300  RFC 2601〜2700  RFC 4001〜4100  RFC 5401〜5500 
 RFC 1301〜1400  RFC 2701〜2800  RFC 4101〜4200 

スポンサーリンク

Ubuntu/Debian/Raspberry PiでChia Network(XCH)をHDDマイニングする方法

ホームページ製作・web系アプリ系の製作案件募集中です。

上に戻る