luna - wolfssl/doc/dox_comments/header

   1/*!
   2    \ingroup AES
   3    \brief この関数は、キーを設定し、初期化ベクトルを設定することでAES構造体を初期化します。
   4
   5    \return 0 キーと初期化ベクトルの設定に成功した場合に返されます。
   6    \return BAD_FUNC_ARG キーの長さが無効な場合に返されます。
   7
   8    \param aes 変更するAES構造体へのポインタ
   9    \param key 暗号化と復号のための16、24、または32バイトの秘密鍵
  10    \param len 渡されたキーの長さ
  11    \param iv キーの初期化に使用される初期化ベクトルへのポインタ
  12    \param dir 暗号の方向。暗号化する場合はAES_ENCRYPTIONを設定し、復号する場合はAES_DECRYPTIONを設定します。一部のモード（CFBおよびCTR）の方向は常にAES_ENCRYPTIONです。
  13
  14    _Example_
  15    \code
  16    Aes enc;
  17    int ret = 0;
  18    byte key[] = { 16、24、または32バイトのキー };
  19    byte iv[]  = { 16バイトのiv };
  20    if (ret = wc_AesInit(&enc, HEAP_HINT, INVALID_DEVID) != 0) {
  21        // aes keyの初期化に失敗
  22    }
  23    if (ret = wc_AesSetKey(&enc, key, AES_BLOCK_SIZE, iv,
  24    AES_ENCRYPTION) != 0) {
  25	// aes keyの設定に失敗
  26    }
  27    \endcode
  28
  29    \sa wc_AesSetKeyDirect
  30    \sa wc_AesSetIV
  31*/
  32int  wc_AesSetKey(Aes* aes, const byte* key, word32 len,
  33                              const byte* iv, int dir);
  34
  35/*!
  36    \ingroup AES
  37    \brief この関数は、特定のAESオブジェクトの初期化ベクトルを設定します。この関数を呼び出す前にAESオブジェクトを初期化する必要があります。
  38
  39    \return 0 初期化ベクトルの設定に成功した場合に返されます。
  40    \return BAD_FUNC_ARG AESポインタがNULLの場合に返されます。
  41
  42    \param aes 初期化ベクトルを設定するAES構造体へのポインタ
  43    \param iv AES構造体を初期化するために使用される初期化ベクトル。値がNULLの場合、デフォルトの動作はivを0に初期化します。
  44
  45    _Example_
  46    \code
  47    Aes enc;
  48    // enc keyを設定
  49    byte iv[]  = { 16バイトのiv };
  50    if (ret = wc_AesSetIV(&enc, iv) != 0) {
  51	// aes ivの設定に失敗
  52    }
  53    \endcode
  54
  55    \sa wc_AesSetKeyDirect
  56    \sa wc_AesSetKey
  57*/
  58int  wc_AesSetIV(Aes* aes, const byte* iv);
  59
  60/*!
  61    \ingroup AES
  62    \brief 入力バッファinから平文メッセージを暗号化し、AESを使用した暗号ブロック連鎖により結果の暗号文を出力バッファoutに格納します。この関数は、メッセージを暗号化する前にAesSetKeyを呼び出してAESオブジェクトが初期化されている必要があります。この関数は、入力メッセージがAESブロック長に整列していることを前提としており、入力長がブロック長の倍数であることを期待します。ビルド構成でWOLFSSL_AES_CBC_LENGTH_CHECKSが定義されている場合、これはオプションでチェックおよび強制されます。ブロック倍数の入力を保証するために、事前にPKCS#7スタイルのパディングを追加する必要があります。これは、自動的にパディングを追加するOpenSSLのAES-CBCメソッドとは異なります。wolfSSLと対応するOpenSSL関数を相互運用させるには、OpenSSLコマンドライン関数で-nopadオプションを指定して、wolfSSLのAesCbcEncryptメソッドのように動作し、暗号化中に余分なパディングを追加しないようにする必要があります。
  63
  64    \return 0 メッセージの暗号化に成功した場合に返されます。
  65    \return BAD_ALIGN_E ブロック整列エラーで返される場合があります。
  66    \return BAD_LENGTH_E ライブラリがWOLFSSL_AES_CBC_LENGTH_CHECKSでビルドされている場合、入力長がAESブロック長の倍数でない場合に返されます。
  67
  68    \param aes データを暗号化するために使用されるAESオブジェクトへのポインタ
  69    \param out 暗号化されたメッセージの暗号文を格納する出力バッファへのポインタ
  70    \param in 暗号化されるメッセージを含む入力バッファへのポインタ
  71    \param sz 入力メッセージのサイズ
  72
  73    _Example_
  74    \code
  75    Aes enc;
  76    int ret = 0;
  77    // wc_AesInitとwc_AesSetKeyを使用してencを初期化、方向は
  78    // AES_ENCRYPTIONを使用
  79    byte msg[AES_BLOCK_SIZE * n]; // 16バイトの倍数
  80    // msgにデータを入力
  81    byte cipher[AES_BLOCK_SIZE * n]; // 16バイトの倍数
  82    if ((ret = wc_AesCbcEncrypt(&enc, cipher, message, sizeof(msg))) != 0 ) {
  83	// ブロック整列エラー
  84    }
  85    \endcode
  86
  87    \sa wc_AesInit
  88    \sa wc_AesSetKey
  89    \sa wc_AesSetIV
  90    \sa wc_AesCbcDecrypt
  91*/
  92int  wc_AesCbcEncrypt(Aes* aes, byte* out,
  93                                  const byte* in, word32 sz);
  94
  95/*!
  96    \ingroup AES
  97    \brief 入力バッファinから暗号を復号し、AESを使用した暗号ブロック連鎖により結果の平文を出力バッファoutに格納します。この関数は、メッセージを復号する前にAesSetKeyを呼び出してAES構造体が初期化されている必要があります。この関数は、元のメッセージがAESブロック長に整列していたことを前提としており、入力長がブロック長の倍数であることを期待します。ビルド構成でWOLFSSL_AES_CBC_LENGTH_CHECKSが定義されている場合、これはオプションでチェックおよび強制されます。これは、PKCS#7パディングを自動的に追加するOpenSSLのAES-CBCメソッドとは異なり、ブロック倍数の入力を必要としません。wolfSSL関数と同等のOpenSSL関数を相互運用させるには、OpenSSLコマンドライン関数で-nopadオプションを指定して、wolfSSLのAesCbcEncryptメソッドのように動作し、復号中にエラーを発生させないようにする必要があります。
  98
  99    \return 0 メッセージの復号に成功した場合に返されます。
 100    \return BAD_ALIGN_E ブロック整列エラーで返される場合があります。
 101    \return BAD_LENGTH_E ライブラリがWOLFSSL_AES_CBC_LENGTH_CHECKSでビルドされている場合、入力長がAESブロック長の倍数でない場合に返されます。
 102
 103    \param aes データを復号するために使用されるAESオブジェクトへのポインタ。
 104    \param out 復号されたメッセージの平文を格納する出力バッファへのポインタ。
 105    サイズはAES_BLOCK_LENGTHの倍数である必要があり、必要に応じてパディングされます
 106    \param in 復号される暗号文を含む入力バッファへのポインタ。
 107    サイズはAES_BLOCK_LENGTHの倍数である必要があり、必要に応じてパディングされます
 108    \param sz 入力メッセージのサイズ。
 109
 110    _Example_
 111    \code
 112    Aes dec;
 113    int ret = 0;
 114    // wc_AesInitとwc_AesSetKeyを使用してdecを初期化、方向は
 115    // AES_DECRYPTIONを使用
 116    byte cipher[AES_BLOCK_SIZE * n]; // 16バイトの倍数
 117    // cipherに暗号文を入力
 118    byte plain [AES_BLOCK_SIZE * n];
 119    if ((ret = wc_AesCbcDecrypt(&dec, plain, cipher, sizeof(cipher))) != 0 ) {
 120	// ブロック整列エラー
 121    }
 122    \endcode
 123
 124    \sa wc_AesInit
 125    \sa wc_AesSetKey
 126    \sa wc_AesCbcEncrypt
 127*/
 128int  wc_AesCbcDecrypt(Aes* aes, byte* out,
 129                                  const byte* in, word32 sz);
 130
 131/*!
 132    \ingroup AES
 133    \brief AESを使用したCTRモードで、入力バッファinからメッセージを暗号化/復号し、結果の暗号文を出力バッファoutに格納します。この関数は、コンパイル時にWOLFSSL_AES_COUNTERが有効になっている場合のみ有効です。この関数を呼び出す前に、AesSetKeyを介してAES構造体を初期化する必要があります。この関数は復号と暗号化の両方に使用されることに注意してください。注：暗号化と復号に同じAPIを使用することについて。ユーザは暗号化/復号用のAes構造体を区別する必要があります。
 134
 135    \return int wolfSSLエラーまたは成功ステータスに対応する整数値
 136
 137    \param aes データを復号するために使用されるAESオブジェクトへのポインタ
 138    \param out 暗号化されたメッセージの暗号文を格納する出力バッファへのポインタ
 139    サイズはAES_BLOCK_LENGTHの倍数である必要があり、必要に応じてパディングされます
 140    \param in 暗号化される平文を含む入力バッファへのポインタ
 141    サイズはAES_BLOCK_LENGTHの倍数である必要があり、必要に応じてパディングされます
 142    \param sz 入力平文のサイズ
 143
 144    _Example_
 145    \code
 146    Aes enc;
 147    Aes dec;
 148    // wc_AesInitとwc_AesSetKeyDirectを使用してencとdecを初期化、方向は
 149    // AES_ENCRYPTIONを使用。基盤となるAPIは暗号化のみを呼び出し、
 150    // デフォルトで暗号に対して暗号化を呼び出すと暗号の復号が
 151    // 行われるため
 152
 153    byte msg[AES_BLOCK_SIZE * n]; // nは正の整数で、msgを
 154    16バイトの倍数にする
 155    // plainにメッセージテキストを入力
 156    byte cipher[AES_BLOCK_SIZE * n];
 157    byte decrypted[AES_BLOCK_SIZE * n];
 158    wc_AesCtrEncrypt(&enc, cipher, msg, sizeof(msg)); // plainを暗号化
 159    wc_AesCtrEncrypt(&dec, decrypted, cipher, sizeof(cipher));
 160    // 暗号文を復号
 161    \endcode
 162
 163    \sa wc_AesSetKey
 164*/
 165int wc_AesCtrEncrypt(Aes* aes, byte* out,
 166                                   const byte* in, word32 sz);
 167
 168/*!
 169    \ingroup AES
 170    \brief この関数は、入力ブロックinの1ブロック暗号化を出力ブロックoutに行います。提供されたAES構造体のキーを使用し、この関数を呼び出す前にwc_AesSetKeyで初期化する必要があります。wc_AesSetKeyはivをNULLに設定して呼び出す必要があります。これは、構成オプションWOLFSSL_AES_DIRECTが有効になっている場合のみ有効です。警告：ほぼすべてのユースケースで、ECBモードは安全性が低いと考えられています。可能な限りECB APIを直接使用することは避けてください。
 171
 172    \return int wolfSSLエラーまたは成功ステータスに対応する整数値
 173
 174    \param aes データを暗号化するために使用されるAESオブジェクトへのポインタ
 175    \param out 暗号化されたメッセージの暗号文を格納する出力バッファへのポインタ
 176    \param in 暗号化される平文を含む入力バッファへのポインタ
 177
 178    _Example_
 179    \code
 180    Aes enc;
 181    // wc_AesInitとwc_AesSetKeyを使用してencを初期化、方向は
 182    // AES_ENCRYPTIONを使用
 183    byte msg [AES_BLOCK_SIZE]; // 16バイト
 184    // msgを暗号化する平文で初期化
 185    byte cipher[AES_BLOCK_SIZE];
 186    wc_AesEncryptDirect(&enc, cipher, msg);
 187    \endcode
 188
 189    \sa wc_AesDecryptDirect
 190    \sa wc_AesSetKeyDirect
 191*/
 192int wc_AesEncryptDirect(Aes* aes, byte* out, const byte* in);
 193
 194/*!
 195    \ingroup AES
 196    \brief この関数は、入力ブロックinの1ブロック復号を出力ブロックoutに行います。提供されたAES構造体のキーを使用し、この関数を呼び出す前にwc_AesSetKeyで初期化する必要があります。wc_AesSetKeyはivをNULLに設定して呼び出す必要があります。これは、構成オプションWOLFSSL_AES_DIRECTが有効になっている場合のみ有効です。警告：ほぼすべてのユースケースで、ECBモードは安全性が低いと考えられています。可能な限りECB APIを直接使用することは避けてください。
 197
 198    \return int wolfSSLエラーまたは成功ステータスに対応する整数値
 199
 200    \param aes データを暗号化するために使用されるAESオブジェクトへのポインタ
 201    \param out 復号された暗号文の平文を格納する出力バッファへのポインタ
 202    \param in 復号される暗号文を含む入力バッファへのポインタ
 203
 204    _Example_
 205    \code
 206    Aes dec;
 207    // wc_AesInitとwc_AesSetKeyを使用してencを初期化、方向は
 208    // AES_DECRYPTIONを使用
 209    byte cipher [AES_BLOCK_SIZE]; // 16バイト
 210    // cipherを復号する暗号文で初期化
 211    byte msg[AES_BLOCK_SIZE];
 212    wc_AesDecryptDirect(&dec, msg, cipher);
 213    \endcode
 214
 215    \sa wc_AesEncryptDirect
 216    \sa wc_AesSetKeyDirect
 217 */
 218int wc_AesDecryptDirect(Aes* aes, byte* out, const byte* in);
 219
 220/*!
 221    \ingroup AES
 222    \brief この関数は、AESを使用したCTRモードのAESキーを設定するために使用されます。指定されたキー、iv（初期化ベクトル）、および暗号化dir（方向）でAESオブジェクトを初期化します。構成オプションWOLFSSL_AES_DIRECTが有効になっている場合のみ有効です。現在、wc_AesSetKeyDirectは内部的にwc_AesSetKeyを使用しています。警告：ほぼすべてのユースケースで、ECBモードは安全性が低いと考えられています。可能な限りECB APIを直接使用することは避けてください。
 223
 224    \return 0 キーの設定に成功した場合に返されます。
 225    \return BAD_FUNC_ARG 指定されたキーの長さが無効な場合に返されます。
 226
 227    \param aes データを暗号化するために使用されるAESオブジェクトへのポインタ
 228    \param key 暗号化と復号のための16、24、または32バイトの秘密鍵
 229    \param len 渡されたキーの長さ
 230    \param iv キーの初期化に使用される初期化ベクトル
 231    \param dir 暗号の方向。暗号化する場合はAES_ENCRYPTIONを設定し、復号する場合はAES_DECRYPTIONを設定します。（wolfssl/wolfcrypt/aes.hの列挙型を参照）（注：Aesカウンタモード（ストリーム暗号）でwc_AesSetKeyDirectを使用する場合、暗号化と復号の両方にAES_ENCRYPTIONのみを使用）
 232
 233    _Example_
 234    \code
 235    Aes enc;
 236    int ret = 0;
 237    byte key[] = { 16、24、または32バイトのキー };
 238    byte iv[]  = { 16バイトのiv };
 239
 240    if (ret = wc_AesInit(&enc, HEAP_HINT, INVALID_DEVID) != 0) {
 241        // aes keyの初期化に失敗
 242    }
 243    if (ret = wc_AesSetKeyDirect(&enc, key, sizeof(key), iv,
 244    AES_ENCRYPTION) != 0) {
 245	// aes keyの設定に失敗
 246    }
 247    \endcode
 248
 249    \sa wc_AesEncryptDirect
 250    \sa wc_AesDecryptDirect
 251    \sa wc_AesSetKey
 252*/
 253int  wc_AesSetKeyDirect(Aes* aes, const byte* key, word32 len,
 254                                const byte* iv, int dir);
 255
 256/*!
 257    \ingroup AES
 258    \brief この関数は、AES GCM（Galois/Counter Mode）のキーを設定するために使用されます。指定されたキーでAESオブジェクトを初期化します。コンパイル時に構成オプションHAVE_AESGCMが有効になっている場合のみ有効です。
 259
 260    \return 0 キーの設定に成功した場合に返されます。
 261    \return BAD_FUNC_ARG 指定されたキーの長さが無効な場合に返されます。
 262
 263    \param aes データを暗号化するために使用されるAESオブジェクトへのポインタ
 264    \param key 暗号化と復号のための16、24、または32バイトの秘密鍵
 265    \param len 渡されたキーの長さ
 266
 267    _Example_
 268    \code
 269    Aes enc;
 270    int ret = 0;
 271    byte key[] = { 16、24、32バイトのキー };
 272    if (ret = wc_AesInit(&enc, HEAP_HINT, INVALID_DEVID) != 0) {
 273        // aes keyの初期化に失敗
 274    }
 275    if (ret = wc_AesGcmSetKey(&enc, key, sizeof(key)) != 0) {
 276	// aes keyの設定に失敗
 277    }
 278    \endcode
 279
 280    \sa wc_AesGcmEncrypt
 281    \sa wc_AesGcmDecrypt
 282*/
 283int  wc_AesGcmSetKey(Aes* aes, const byte* key, word32 len);
 284
 285/*!
 286    \ingroup AES
 287    \brief この関数は、バッファinに保持されている入力メッセージを暗号化し、結果の暗号文を出力バッファoutに格納します。暗号化の呼び出しごとに新しいiv（初期化ベクトル）が必要です。また、入力認証ベクトルauthInを認証タグauthTagにエンコードします。
 288
 289    \return 0 入力メッセージの暗号化に成功した場合に返されます
 290
 291    \param aes データを暗号化するために使用されるAESオブジェクトへのポインタ
 292    \param out 暗号文を格納する出力バッファへのポインタ
 293    サイズはinのサイズ（sz）と一致する必要があります
 294    \param in 暗号化するメッセージを保持する入力バッファへのポインタ
 295    サイズはAES_BLOCK_LENGTHの倍数である必要があり、必要に応じてパディングされます
 296    \param sz 暗号化する入力メッセージの長さ
 297    \param iv 初期化ベクトルを含むバッファへのポインタ
 298    \param ivSz 初期化ベクトルの長さ
 299    \param authTag 認証タグを格納するバッファへのポインタ
 300    \param authTagSz 希望する認証タグの長さ
 301    \param authIn 入力認証ベクトルを含むバッファへのポインタ
 302    \param authInSz 入力認証ベクトルの長さ
 303
 304    _Example_
 305    \code
 306    Aes enc;
 307    // wc_AesInit()とwc_AesGcmSetKeyを呼び出してAes構造体を初期化
 308
 309    byte plain[AES_BLOCK_LENGTH * n]; // nは正の整数で
 310    plainを16バイトの倍数にする
 311    // plainを暗号化するメッセージで初期化
 312    byte cipher[sizeof(plain)];
 313    byte iv[] = // 16バイトのiv
 314    byte authTag[AUTH_TAG_LENGTH];
 315    byte authIn[] = // 認証ベクトル
 316
 317    wc_AesGcmEncrypt(&enc, cipher, plain, sizeof(cipher), iv, sizeof(iv),
 318		authTag, sizeof(authTag), authIn, sizeof(authIn));
 319    \endcode
 320
 321    \sa wc_AesGcmSetKey
 322    \sa wc_AesGcmDecrypt
 323*/
 324int  wc_AesGcmEncrypt(Aes* aes, byte* out,
 325                                   const byte* in, word32 sz,
 326                                   const byte* iv, word32 ivSz,
 327                                   byte* authTag, word32 authTagSz,
 328                                   const byte* authIn, word32 authInSz);
 329
 330/*!
 331    \ingroup AES
 332    \brief この関数は、バッファinに保持されている入力暗号文を復号し、結果のメッセージテキストを出力バッファoutに格納します。また、入力認証ベクトルauthInを、提供された認証タグauthTagと照合してチェックします。ゼロ以外のエラーコードが返された場合、出力データは未定義です。ただし、呼び出し元は平文データの漏洩を防ぐために、無条件に出力バッファをゼロ化する必要があります。
 333
 334    \return 0 入力メッセージの復号と認証に成功した場合に返されます
 335    \return AES_GCM_AUTH_E 認証タグが提供された認証コードベクトルauthTagと一致しない場合に返されます。
 336
 337    \param aes データを暗号化するために使用されるAESオブジェクトへのポインタ
 338    \param out メッセージテキストを格納する出力バッファへのポインタ
 339    サイズはinのサイズ（sz）と一致する必要があります
 340    \param in 復号する暗号文を保持する入力バッファへのポインタ
 341    サイズはAES_BLOCK_LENGTHの倍数である必要があり、必要に応じてパディングされます
 342    \param sz 復号する暗号文の長さ
 343    \param iv 初期化ベクトルを含むバッファへのポインタ
 344    \param ivSz 初期化ベクトルの長さ
 345    \param authTag 認証タグを含むバッファへのポインタ
 346    \param authTagSz 希望する認証タグの長さ
 347    \param authIn 入力認証ベクトルを含むバッファへのポインタ
 348    \param authInSz 入力認証ベクトルの長さ
 349
 350    _Example_
 351    \code
 352    Aes enc; // wc_AesGcmEncryptに渡されたものと同じ構造体を使用可能
 353    // まだ完了していない場合は、wc_AesInitとwc_AesGcmSetKeyを呼び出して
 354    // aes構造体を初期化
 355
 356    byte cipher[AES_BLOCK_LENGTH * n]; // nは正の整数で
 357    cipherを16バイトの倍数にする
 358    // cipherを復号する暗号文で初期化
 359    byte output[sizeof(cipher)];
 360    byte iv[] = // 16バイトのiv
 361    byte authTag[AUTH_TAG_LENGTH];
 362    byte authIn[] = // 認証ベクトル
 363
 364    wc_AesGcmDecrypt(&enc, output, cipher, sizeof(cipher), iv, sizeof(iv),
 365		authTag, sizeof(authTag), authIn, sizeof(authIn));
 366    \endcode
 367
 368    \sa wc_AesGcmSetKey
 369    \sa wc_AesGcmEncrypt
 370*/
 371int  wc_AesGcmDecrypt(Aes* aes, byte* out,
 372                                   const byte* in, word32 sz,
 373                                   const byte* iv, word32 ivSz,
 374                                   const byte* authTag, word32 authTagSz,
 375                                   const byte* authIn, word32 authInSz);
 376
 377/*!
 378    \ingroup AES
 379    \brief この関数は、Galoisメッセージ認証に使用されるGMACオブジェクトのキーを初期化および設定します。
 380
 381    \return 0 キーの設定に成功した場合に返されます
 382    \return BAD_FUNC_ARG キーの長さが無効な場合に返されます。
 383
 384    \param gmac 認証に使用されるgmacオブジェクトへのポインタ
 385    \param key 認証のための16、24、または32バイトの秘密鍵
 386    \param len キーの長さ
 387
 388    _Example_
 389    \code
 390    Gmac gmac;
 391    key[] = { 16、24、または32バイト長のキー };
 392    wc_AesInit(gmac.aes, HEAP_HINT, INVALID_DEVID); // devIdが更新されていることを確認
 393    wc_GmacSetKey(&gmac, key, sizeof(key));
 394    \endcode
 395
 396    \sa wc_GmacUpdate
 397    \sa wc_AesInit
 398*/
 399int wc_GmacSetKey(Gmac* gmac, const byte* key, word32 len);
 400
 401/*!
 402    \ingroup AES
 403    \brief この関数は、authIn入力のGmacハッシュを生成し、結果をauthTagバッファに格納します。wc_GmacUpdateを実行した後、生成されたauthTagを既知の認証タグと比較して、メッセージの真正性を検証する必要があります。
 404
 405    \return 0 Gmacハッシュの計算に成功した場合に返されます。
 406
 407    \param gmac 認証に使用されるgmacオブジェクトへのポインタ
 408    \param iv ハッシュに使用される初期化ベクトル
 409    \param ivSz 使用される初期化ベクトルのサイズ
 410    \param authIn 検証する認証ベクトルを含むバッファへのポインタ
 411    \param authInSz 認証ベクトルのサイズ
 412    \param authTag Gmacハッシュを格納する出力バッファへのポインタ
 413    \param authTagSz Gmacハッシュを格納するために使用される出力バッファのサイズ
 414
 415    _Example_
 416    \code
 417    Gmac gmac;
 418    key[] = { 16、24、または32バイト長のキー };
 419    iv[] = { 16バイト長のiv };
 420
 421    wc_AesInit(gmac.aes, HEAP_HINT, INVALID_DEVID); // devIdが更新されていることを確認
 422    wc_GmacSetKey(&gmac, key, sizeof(key));
 423    authIn[] = { 16バイトの認証入力 };
 424    tag[AES_BLOCK_SIZE]; // 認証コードを格納
 425
 426    wc_GmacUpdate(&gmac, iv, sizeof(iv), authIn, sizeof(authIn), tag,
 427    sizeof(tag));
 428    \endcode
 429
 430    \sa wc_GmacSetKey
 431    \sa wc_AesInit
 432*/
 433int wc_GmacUpdate(Gmac* gmac, const byte* iv, word32 ivSz,
 434                               const byte* authIn, word32 authInSz,
 435                               byte* authTag, word32 authTagSz);
 436
 437/*!
 438    \ingroup AES
 439    \brief この関数は、CCM（Counter with CBC-MAC）を使用してAESオブジェクトのキーを設定します。AES構造体へのポインタを受け取り、提供されたキーで初期化します。
 440
 441    \return none
 442
 443    \param aes 提供されたキーを格納するaes構造体
 444    \param key 暗号化と復号のための16、24、または32バイトの秘密鍵
 445    \param keySz 提供されたキーのサイズ
 446
 447    _Example_
 448    \code
 449    Aes enc;
 450    key[] = { 16、24、または32バイト長のキー };
 451
 452    wc_AesInit(&enc, HEAP_HINT, INVALID_DEVID); // devIdが更新されていることを確認
 453    wc_AesCcmSetKey(&enc, key, sizeof(key));
 454    \endcode
 455
 456    \sa wc_AesCcmEncrypt
 457    \sa wc_AesCcmDecrypt
 458*/
 459int  wc_AesCcmSetKey(Aes* aes, const byte* key, word32 keySz);
 460
 461/*!
 462    \ingroup AES
 463
 464    \brief この関数は、CCM（Counter with CBC-MAC）を使用して、入力メッセージinを出力バッファoutに暗号化します。その後、authIn入力から認証タグauthTagを計算して格納します。
 465
 466    \return none
 467
 468    \param aes データを暗号化するために使用されるAESオブジェクトへのポインタ
 469    \param out 暗号文を格納する出力バッファへのポインタ
 470    \param in 暗号化するメッセージを保持する入力バッファへのポインタ
 471    \param sz 暗号化する入力メッセージの長さ
 472    \param nonce ナンス（1回のみ使用される数値）を含むバッファへのポインタ
 473    \param nonceSz ナンスの長さ
 474    \param authTag 認証タグを格納するバッファへのポインタ
 475    \param authTagSz 希望する認証タグの長さ
 476    \param authIn 入力認証ベクトルを含むバッファへのポインタ
 477    \param authInSz 入力認証ベクトルの長さ
 478
 479    _Example_
 480    \code
 481    Aes enc;
 482    // wc_AesInitとwc_AesCcmSetKeyでencを初期化
 483
 484    nonce[] = { ナンスを初期化 };
 485    plain[] = { 平文メッセージ };
 486    cipher[sizeof(plain)];
 487
 488    authIn[] = { 16バイトの認証入力 };
 489    tag[AES_BLOCK_SIZE]; // 認証コードを格納
 490
 491    wc_AesCcmEncrypt(&enc, cipher, plain, sizeof(plain), nonce, sizeof(nonce),
 492		tag, sizeof(tag), authIn, sizeof(authIn));
 493    \endcode
 494
 495    \sa wc_AesCcmSetKey
 496    \sa wc_AesCcmDecrypt
 497*/
 498int  wc_AesCcmEncrypt(Aes* aes, byte* out,
 499                                   const byte* in, word32 inSz,
 500                                   const byte* nonce, word32 nonceSz,
 501                                   byte* authTag, word32 authTagSz,
 502                                   const byte* authIn, word32 authInSz);
 503
 504/*!
 505    \ingroup AES
 506
 507    \brief この関数は、CCM（Counter with CBC-MAC）を使用して、入力暗号文inを出力バッファoutに復号します。その後、authIn入力から認証タグauthTagを計算します。ゼロ以外のエラーコードが返された場合、出力データは未定義です。ただし、呼び出し元は平文データの漏洩を防ぐために、無条件に出力バッファをゼロ化する必要があります。
 508
 509    \return 0 入力メッセージの復号に成功した場合に返されます
 510    \return AES_CCM_AUTH_E 認証タグが提供された認証コードベクトルauthTagと一致しない場合に返されます。
 511
 512    \param aes データを暗号化するために使用されるAESオブジェクトへのポインタ
 513    \param out 暗号文を格納する出力バッファへのポインタ
 514    \param in 暗号化するメッセージを保持する入力バッファへのポインタ
 515    \param sz 復号する入力暗号文の長さ
 516    \param nonce ナンス（1回のみ使用される数値）を含むバッファへのポインタ
 517    \param nonceSz ナンスの長さ
 518    \param authTag 認証タグを格納するバッファへのポインタ
 519    \param authTagSz 希望する認証タグの長さ
 520    \param authIn 入力認証ベクトルを含むバッファへのポインタ
 521    \param authInSz 入力認証ベクトルの長さ
 522
 523    _Example_
 524    \code
 525    Aes dec;
 526    // wc_AesInitとwc_AesCcmSetKeyでdecを初期化
 527
 528    nonce[] = { ナンスを初期化 };
 529    cipher[] = { 暗号化されたメッセージ };
 530    plain[sizeof(cipher)];
 531
 532    authIn[] = { 16バイトの認証入力 };
 533    tag[AES_BLOCK_SIZE] = { 検証のために受信した認証タグ };
 534
 535    int return = wc_AesCcmDecrypt(&dec, plain, cipher, sizeof(cipher),
 536    nonce, sizeof(nonce),tag, sizeof(tag), authIn, sizeof(authIn));
 537    if(return != 0) {
 538	// 復号エラー、無効な認証コード
 539    }
 540    \endcode
 541
 542    \sa wc_AesCcmSetKey
 543    \sa wc_AesCcmEncrypt
 544*/
 545int  wc_AesCcmDecrypt(Aes* aes, byte* out,
 546                                   const byte* in, word32 inSz,
 547                                   const byte* nonce, word32 nonceSz,
 548                                   const byte* authTag, word32 authTagSz,
 549                                   const byte* authIn, word32 authInSz);
 550
 551/*!
 552    \ingroup AES
 553
 554    \brief これはAES-XTSコンテキストを初期化するためのものです。使用が完了したら、ユーザがaesキーに対してwc_AesXtsFreeを呼び出す必要があります。
 555
 556    \return 0 成功
 557
 558    \param aes   暗号化/復号プロセスのためのAESキー
 559    \param heap  メモリに使用するヒープヒント。NULLでも可
 560    \param devId 暗号コールバックまたは非同期ハードウェアで使用するID。使用しない場合はINVALID_DEVID（-2）に設定
 561
 562    _Example_
 563    \code
 564    XtsAes aes;
 565
 566    if(wc_AesXtsInit(&aes, NULL, INVALID_DEVID) != 0)
 567    {
 568        // エラーを処理
 569    }
 570    if(wc_AesXtsSetKeyNoInit(&aes, key, sizeof(key), AES_ENCRYPTION) != 0)
 571    {
 572        // エラーを処理
 573    }
 574    wc_AesXtsFree(&aes);
 575    \endcode
 576
 577    \sa wc_AesXtsSetKey
 578    \sa wc_AesXtsSetKeyNoInit
 579    \sa wc_AesXtsEncrypt
 580    \sa wc_AesXtsDecrypt
 581    \sa wc_AesXtsFree
 582*/
 583int wc_AesXtsInit(XtsAes* aes, void* heap, int devId);
 584
 585
 586/*!
 587    \ingroup AES
 588
 589    \brief これは、最初にwc_AesXtsInit()を呼び出した後、キーを正しい暗号化または復号タイプに設定するのに役立ちます。使用が完了したら、ユーザがaesキーに対してwc_AesXtsFreeを呼び出す必要があります。
 590
 591    \return 0 成功
 592
 593    \param aes   暗号化/復号プロセスのためのAESキー
 594    \param key   aesキー | tweakキーを保持するバッファ
 595    \param len   キーバッファの長さ（バイト単位）。キーサイズの2倍である必要があります。
 596                 つまり、16バイトのキーの場合は32です。
 597    \param dir   方向、AES_ENCRYPTIONまたはAES_DECRYPTION
 598
 599    _Example_
 600    \code
 601    XtsAes aes;
 602
 603    if(wc_AesXtsInit(&aes, NULL, 0) != 0)
 604    {
 605        // エラーを処理
 606    }
 607    if(wc_AesXtsSetKeyNoInit(&aes, key, sizeof(key), AES_ENCRYPTION, NULL, 0)
 608       != 0)
 609    {
 610        // エラーを処理
 611    }
 612    wc_AesXtsFree(&aes);
 613    \endcode
 614
 615    \sa wc_AesXtsEncrypt
 616    \sa wc_AesXtsDecrypt
 617    \sa wc_AesXtsFree
 618*/
 619int wc_AesXtsSetKeyNoInit(XtsAes* aes, const byte* key,
 620         word32 len, int dir);
 621
 622
 623/*!
 624    \ingroup AES
 625
 626    \brief これは、キーを正しい暗号化または復号タイプに設定するのに役立ちます。使用が完了したら、ユーザがaesキーに対してwc_AesXtsFreeを呼び出す必要があります。
 627
 628    \return 0 成功
 629
 630    \param aes   暗号化/復号プロセスのためのAESキー
 631    \param key   aesキー | tweakキーを保持するバッファ
 632    \param len   キーバッファの長さ（バイト単位）。キーサイズの2倍である必要があります。
 633                 つまり、16バイトのキーの場合は32です。
 634    \param dir   方向、AES_ENCRYPTIONまたはAES_DECRYPTION
 635    \param heap  メモリに使用するヒープヒント。NULLでも可
 636    \param devId 暗号コールバックまたは非同期ハードウェアで使用するID。使用しない場合はINVALID_DEVID（-2）に設定
 637
 638    _Example_
 639    \code
 640    XtsAes aes;
 641
 642    if(wc_AesXtsSetKey(&aes, key, sizeof(key), AES_ENCRYPTION, NULL, INVALID_DEVID) != 0)
 643    {
 644        // エラーを処理
 645    }
 646    wc_AesXtsFree(&aes);
 647    \endcode
 648
 649    \sa wc_AesXtsInit
 650    \sa wc_AesXtsSetKeyNoInit
 651    \sa wc_AesXtsEncrypt
 652    \sa wc_AesXtsDecrypt
 653    \sa wc_AesXtsFree
 654*/
 655int wc_AesXtsSetKey(XtsAes* aes, const byte* key,
 656         word32 len, int dir, void* heap, int devId);
 657
 658/*!
 659    \ingroup AES
 660
 661    \brief wc_AesXtsEncryptと同じプロセスですが、バイト配列の代わりにword64型をtweak値として使用します。これはword64をバイト配列に変換し、wc_AesXtsEncryptを呼び出すだけです。
 662
 663    \return 0 成功
 664
 665    \param aes    ブロック暗号化/復号に使用するAESキー
 666    \param out    暗号文を保持する出力バッファ
 667    \param in     暗号化する入力平文バッファ
 668    \param sz     outとinバッファの両方のサイズ
 669    \param sector tweakに使用する値
 670
 671    _Example_
 672    \code
 673    XtsAes aes;
 674    unsigned char plain[SIZE];
 675    unsigned char cipher[SIZE];
 676    word64 s = VALUE;
 677
 678    // AES_ENCRYPTIONをdirとしてキーを設定
 679    if(wc_AesXtsEncryptSector(&aes, cipher, plain, SIZE, s) != 0)
 680    {
 681        // エラーを処理
 682    }
 683    wc_AesXtsFree(&aes);
 684    \endcode
 685
 686    \sa wc_AesXtsEncrypt
 687    \sa wc_AesXtsDecrypt
 688    \sa wc_AesXtsInit
 689    \sa wc_AesXtsSetKeyNoInit
 690    \sa wc_AesXtsSetKey
 691    \sa wc_AesXtsFree
 692*/
 693int wc_AesXtsEncryptSector(XtsAes* aes, byte* out,
 694         const byte* in, word32 sz, word64 sector);
 695
 696/*!
 697    \ingroup AES
 698
 699    \brief wc_AesXtsDecryptと同じプロセスですが、バイト配列の代わりにword64型をtweak値として使用します。これはword64をバイト配列に変換するだけです。
 700
 701    \return 0 成功
 702
 703    \param aes    ブロック暗号化/復号に使用するAESキー
 704    \param out    平文を保持する出力バッファ
 705    \param in     復号する入力暗号文バッファ
 706    \param sz     outとinバッファの両方のサイズ
 707    \param sector tweakに使用する値
 708
 709    _Example_
 710    \code
 711    XtsAes aes;
 712    unsigned char plain[SIZE];
 713    unsigned char cipher[SIZE];
 714    word64 s = VALUE;
 715
 716    // AES_DECRYPTIONをdirとしてaesキーを設定し、tweakはAES_ENCRYPTIONで設定
 717
 718    if(wc_AesXtsDecryptSector(&aes, plain, cipher, SIZE, s) != 0)
 719    {
 720        // エラーを処理
 721    }
 722    wc_AesXtsFree(&aes);
 723    \endcode
 724
 725    \sa wc_AesXtsEncrypt
 726    \sa wc_AesXtsDecrypt
 727    \sa wc_AesXtsInit
 728    \sa wc_AesXtsSetKeyNoInit
 729    \sa wc_AesXtsSetKey
 730    \sa wc_AesXtsFree
 731*/
 732int wc_AesXtsDecryptSector(XtsAes* aes, byte* out,
 733         const byte* in, word32 sz, word64 sector);
 734
 735/*!
 736    \ingroup AES
 737
 738    \brief XTSモードのAES。（XTS）TweakとCipher Text Stealingを使用したXEX暗号化。
 739
 740    \return 0 成功
 741
 742    \param aes   ブロック暗号化/復号に使用するAESキー
 743    \param out   暗号文を保持する出力バッファ
 744    \param in    暗号化する入力平文バッファ
 745    \param sz    outとinバッファの両方のサイズ
 746    \param i     tweakに使用する値
 747    \param iSz   iバッファのサイズ、常にAES_BLOCK_SIZEである必要がありますが、この入力を持つことで、ユーザが関数を呼び出す方法についてのサニティチェックが追加されます。
 748
 749    _Example_
 750    \code
 751    XtsAes aes;
 752    unsigned char plain[SIZE];
 753    unsigned char cipher[SIZE];
 754    unsigned char i[AES_BLOCK_SIZE];
 755
 756    // AES_ENCRYPTIONをdirとしてキーを設定
 757
 758    if(wc_AesXtsEncrypt(&aes, cipher, plain, SIZE, i, sizeof(i)) != 0)
 759    {
 760        // エラーを処理
 761    }
 762    wc_AesXtsFree(&aes);
 763    \endcode
 764
 765    \sa wc_AesXtsDecrypt
 766    \sa wc_AesXtsInit
 767    \sa wc_AesXtsSetKeyNoInit
 768    \sa wc_AesXtsSetKey
 769    \sa wc_AesXtsFree
 770*/
 771int wc_AesXtsEncrypt(XtsAes* aes, byte* out,
 772         const byte* in, word32 sz, const byte* i, word32 iSz);
 773
 774/*!
 775    \ingroup AES
 776
 777    \brief 暗号化と同じプロセスですが、AesキーはAES_DECRYPTIONタイプです。
 778
 779    \return 0 成功
 780
 781    \param aes   ブロック暗号化/復号に使用するAESキー
 782    \param out   平文を保持する出力バッファ
 783    \param in    復号する入力暗号文バッファ
 784    \param sz    outとinバッファの両方のサイズ
 785    \param i     tweakに使用する値
 786    \param iSz   iバッファのサイズ、常にAES_BLOCK_SIZEである必要がありますが、この入力を持つことで、ユーザが関数を呼び出す方法についてのサニティチェックが追加されます。
 787
 788    _Example_
 789    \code
 790    XtsAes aes;
 791    unsigned char plain[SIZE];
 792    unsigned char cipher[SIZE];
 793    unsigned char i[AES_BLOCK_SIZE];
 794
 795    // AES_DECRYPTIONをdirとしてキーを設定し、tweakはAES_ENCRYPTIONで設定
 796
 797    if(wc_AesXtsDecrypt(&aes, plain, cipher, SIZE, i, sizeof(i)) != 0)
 798    {
 799        // エラーを処理
 800    }
 801    wc_AesXtsFree(&aes);
 802    \endcode
 803
 804    \sa wc_AesXtsEncrypt
 805    \sa wc_AesXtsInit
 806    \sa wc_AesXtsSetKeyNoInit
 807    \sa wc_AesXtsSetKey
 808    \sa wc_AesXtsFree
 809*/
 810int wc_AesXtsDecrypt(XtsAes* aes, byte* out,
 811        const byte* in, word32 sz, const byte* i, word32 iSz);
 812
 813/*!
 814    \ingroup AES
 815
 816    \brief これは、XtsAes構造体によって使用されるリソースを解放するためのものです
 817
 818    \return 0 成功
 819
 820    \param aes 解放するAESキー
 821
 822    _Example_
 823    \code
 824    XtsAes aes;
 825
 826    if(wc_AesXtsSetKey(&aes, key, sizeof(key), AES_ENCRYPTION, NULL, 0) != 0)
 827    {
 828        // エラーを処理
 829    }
 830    wc_AesXtsFree(&aes);
 831    \endcode
 832
 833    \sa wc_AesXtsEncrypt
 834    \sa wc_AesXtsDecrypt
 835    \sa wc_AesXtsInit
 836    \sa wc_AesXtsSetKeyNoInit
 837    \sa wc_AesXtsSetKey
 838*/
 839int wc_AesXtsFree(XtsAes* aes);
 840
 841
 842/*!
 843    \ingroup AES
 844    \brief Aes構造体を初期化します。使用するヒープヒントと非同期ハードウェアで使用するIDを設定します。使用が完了したら、ユーザがAes構造体に対してwc_AesFreeを呼び出す必要があります。
 845    \return 0 成功
 846
 847    \param aes 初期化するaes構造体
 848    \param heap 必要に応じてmalloc / freeに使用するヒープヒント
 849    \param devId 暗号コールバックまたは非同期ハードウェアで使用するID。使用しない場合はINVALID_DEVID（-2）に設定
 850
 851    _Example_
 852    \code
 853    Aes enc;
 854    void* hint = NULL;
 855    int devId = INVALID_DEVID; // 非同期を使用しない場合はINVALID_DEVIDがデフォルト
 856
 857    // 使用する場合はここでヒープヒントを設定可能
 858
 859    wc_AesInit(&enc, hint, devId);
 860    \endcode
 861
 862    \sa wc_AesSetKey
 863    \sa wc_AesSetIV
 864    \sa wc_AesFree
 865*/
 866int  wc_AesInit(Aes* aes, void* heap, int devId);
 867
 868/*!
 869    \ingroup AES
 870    \brief 該当する場合、Aes構造体に関連付けられたリソースを解放します。内部的には時々no-opになることもありますが、新しい環境で使用するためにアプリケーションコードが移植される場合（呼び出しが適用される場合）など、一般的なベストプラクティスとしてすべてのケースで呼び出すことをお勧めします。
 871    \return no return（void関数）
 872
 873    \param aes 解放するaes構造体
 874
 875    _Example_
 876    \code
 877    Aes enc;
 878    void* hint = NULL;
 879    int devId = INVALID_DEVID; // 非同期を使用しない場合はINVALID_DEVIDがデフォルト
 880
 881    // 使用する場合はここでヒープヒントを設定可能
 882
 883    wc_AesInit(&enc, hint, devId);
 884    // ... 興味深いことをいくつか行う ...
 885    wc_AesFree(&enc);
 886    \endcode
 887
 888    \sa wc_AesInit
 889*/
 890void wc_AesFree(Aes* aes);
 891
 892/*!
 893    \ingroup AES
 894
 895    \brief CFBモードのAES。
 896
 897    \return 0 成功、失敗時は負のエラー値
 898
 899    \param aes   ブロック暗号化/復号に使用するAESキー
 900    \param out   暗号文を保持する出力バッファ（少なくとも入力バッファと同じ大きさである必要があります）
 901    \param in    暗号化する入力平文バッファ
 902    \param sz    入力バッファのサイズ
 903
 904    _Example_
 905    \code
 906    Aes aes;
 907    unsigned char plain[SIZE];
 908    unsigned char cipher[SIZE];
 909
 910    // 暗号化と復号の両方にAES_ENCRYPTIONをdirとしてキーを設定
 911
 912    if(wc_AesCfbEncrypt(&aes, cipher, plain, SIZE) != 0)
 913    {
 914        // エラーを処理
 915    }
 916    \endcode
 917
 918    \sa wc_AesCfbDecrypt
 919    \sa wc_AesSetKey
 920*/
 921int wc_AesCfbEncrypt(Aes* aes, byte* out, const byte* in, word32 sz);
 922
 923/*!
 924    \ingroup AES
 925
 926    \brief CFBモードのAES。
 927
 928    \return 0 成功、失敗時は負のエラー値
 929
 930    \param aes   ブロック暗号化/復号に使用するAESキー
 931    \param out   復号されたテキストを保持する出力バッファ（少なくとも入力バッファと同じ大きさである必要があります）
 932    \param in    復号する入力バッファ
 933    \param sz    入力バッファのサイズ
 934
 935    _Example_
 936    \code
 937    Aes aes;
 938    unsigned char plain[SIZE];
 939    unsigned char cipher[SIZE];
 940
 941    // 暗号化と復号の両方にAES_ENCRYPTIONをdirとしてキーを設定
 942
 943    if(wc_AesCfbDecrypt(&aes, plain, cipher, SIZE) != 0)
 944    {
 945        // エラーを処理
 946    }
 947    \endcode
 948
 949    \sa wc_AesCfbEncrypt
 950    \sa wc_AesSetKey
 951*/
 952int wc_AesCfbDecrypt(Aes* aes, byte* out, const byte* in, word32 sz);
 953
 954/*!
 955    \ingroup AES
 956
 957    \brief この関数は、RFC 5297で説明されているSIV（合成初期化ベクトル）暗号化を実行します。
 958
 959    \return 0 暗号化に成功した場合。
 960    \return BAD_FUNC_ARG key、SIV、または出力バッファがNULLの場合に返されます。また、キーサイズが32、48、または64バイトでない場合にも返されます。
 961    \return Other AESまたはCMAC操作が失敗した場合に返されるその他の負のエラー値。
 962
 963    \param key 使用するキーを含むバイトバッファ。
 964    \param keySz キーバッファの長さ（バイト単位）。
 965    \param assoc 追加の認証された関連データ（AD）。
 966    \param assocSz ADバッファの長さ（バイト単位）。
 967    \param nonce 1回のみ使用される数値。アルゴリズムによってADと同じ方法で使用されます。
 968    \param nonceSz nonceバッファの長さ（バイト単位）。
 969    \param in 暗号化する平文バッファ。
 970    \param inSz 平文バッファの長さ。
 971    \param siv S2Vによって出力されるSIV（RFC 5297 2.4を参照）。
 972    \param out 暗号文を保持するバッファ。平文バッファと同じ長さである必要があります。
 973
 974    _Example_
 975    \code
 976    byte key[] = { 32、48、または64バイトのキー };
 977    byte assoc[] = {0x01, 0x2, 0x3};
 978    byte nonce[] = {0x04, 0x5, 0x6};
 979    byte plainText[] = {0xDE, 0xAD, 0xBE, 0xEF};
 980    byte siv[AES_BLOCK_SIZE];
 981    byte cipherText[sizeof(plainText)];
 982    if (wc_AesSivEncrypt(key, sizeof(key), assoc, sizeof(assoc), nonce,
 983        sizeof(nonce), plainText, sizeof(plainText), siv, cipherText) != 0) {
 984        // 暗号化に失敗
 985    }
 986    \endcode
 987
 988    \sa wc_AesSivDecrypt
 989*/
 990
 991
 992int wc_AesSivEncrypt(const byte* key, word32 keySz, const byte* assoc,
 993                     word32 assocSz, const byte* nonce, word32 nonceSz,
 994                     const byte* in, word32 inSz, byte* siv, byte* out);
 995
 996/*!
 997    \ingroup AES
 998    \brief この関数は、RFC 5297で説明されているSIV（合成初期化ベクトル）復号を実行します。ゼロ以外のエラーコードが返された場合、出力データは未定義です。ただし、呼び出し元は平文データの漏洩を防ぐために、無条件に出力バッファをゼロ化する必要があります。
 999
1000    \return 0 復号に成功した場合。
1001    \return BAD_FUNC_ARG key、SIV、または出力バッファがNULLの場合に返されます。また、キーサイズが32、48、または64バイトでない場合にも返されます。
1002    \return AES_SIV_AUTH_E S2Vによって導出されたSIVが入力SIVと一致しない場合（RFC 5297 2.7を参照）。
1003    \return Other AESまたはCMAC操作が失敗した場合に返されるその他の負のエラー値。
1004
1005    \param key 使用するキーを含むバイトバッファ。
1006    \param keySz キーバッファの長さ（バイト単位）。
1007    \param assoc 追加の認証された関連データ（AD）。
1008    \param assocSz ADバッファの長さ（バイト単位）。
1009    \param nonce 1回のみ使用される数値。基盤となるアルゴリズムによってADと同じ方法で使用されます。
1010    \param nonceSz nonceバッファの長さ（バイト単位）。
1011    \param in 復号する暗号文バッファ。
1012    \param inSz 暗号文バッファの長さ。
1013    \param siv 暗号文に付随するSIV（RFC 5297 2.4を参照）。
1014    \param out 復号された平文を保持するバッファ。暗号文バッファと同じ長さである必要があります。
1015
1016    _Example_
1017    \code
1018    byte key[] = { 32、48、または64バイトのキー };
1019    byte assoc[] = {0x01, 0x2, 0x3};
1020    byte nonce[] = {0x04, 0x5, 0x6};
1021    byte cipherText[] = {0xDE, 0xAD, 0xBE, 0xEF};
1022    byte siv[AES_BLOCK_SIZE] = { 暗号文に付属していたSIV };
1023    byte plainText[sizeof(cipherText)];
1024    if (wc_AesSivDecrypt(key, sizeof(key), assoc, sizeof(assoc), nonce,
1025        sizeof(nonce), cipherText, sizeof(cipherText), siv, plainText) != 0) {
1026        // 復号に失敗
1027    }
1028    \endcode
1029
1030    \sa wc_AesSivEncrypt
1031*/
1032
1033int wc_AesSivDecrypt(const byte* key, word32 keySz, const byte* assoc,
1034                     word32 assocSz, const byte* nonce, word32 nonceSz,
1035                     const byte* in, word32 inSz, byte* siv, byte* out);
1036
1037
1038
1039
1040
1041
1042
1043/*!
1044    \ingroup AES
1045
1046    \brief この関数は、「EAX: A Conventional Authenticated-Encryption Mode」（https://eprint.iacr.org/2003/069）で説明されているAES EAX暗号化と認証を実行します。これは、すべての暗号化と認証操作を1つの関数呼び出しで実行する「ワンショット」APIです。
1047
1048    \return 0 暗号化に成功した場合。
1049    \return BAD_FUNC_ARG 入力または出力バッファがNULLの場合に返されます。また、キーサイズが有効なAESキーサイズ（16、24、または32バイト）でない場合にも返されます
1050    \return other AESまたはCMAC操作が失敗した場合に返されるその他の負のエラー値。
1051
1052    \param [in] key 使用するキーを含むバッファ
1053    \param [in] keySz キーバッファの長さ（バイト単位）
1054    \param [out] out 暗号文を保持するバッファ。平文バッファと同じ長さである必要があります
1055    \param [in] in 暗号化する平文バッファ
1056    \param [in] inSz 平文バッファの長さ
1057    \param [in] nonce EAX操作に使用する暗号ナンス
1058    \param [in] nonceSz nonceバッファの長さ（バイト単位）
1059    \param [out] authTag 認証タグを格納するバッファへのポインタ
1060    \param [in] authTagSz 希望する認証タグの長さ
1061    \param [in] authIn 認証する入力データを含むバッファへのポインタ
1062    \param [in] authInSz 入力認証データの長さ
1063
1064    _Example_
1065    \code
1066    byte key[] = { 32、48、または64バイトのキー };
1067    byte nonce[] = {0x04, 0x5, 0x6};
1068    byte plainText[] = {0xDE, 0xAD, 0xBE, 0xEF};
1069    byte authIn[] = {0x01, 0x2, 0x3};
1070
1071    byte cipherText[sizeof(plainText)]; // 出力暗号文
1072    byte authTag[length, up to AES_BLOCK_SIZE]; // 出力authTag
1073
1074    if (wc_AesEaxEncrypt(key, sizeof(key),
1075                         cipherText, plainText, sizeof(plainText),
1076                         nonce, sizeof(nonce),
1077                         authTag, sizeof(authTag),
1078                         authIn, sizeof(authIn)) != 0) {
1079        // 暗号化に失敗
1080    }
1081
1082    \endcode
1083
1084    \sa wc_AesEaxDecryptAuth
1085
1086*/
1087WOLFSSL_API int  wc_AesEaxEncryptAuth(const byte* key, word32 keySz, byte* out,
1088                                      const byte* in, word32 inSz,
1089                                      const byte* nonce, word32 nonceSz,
1090                                      /* 計算された認証タグの出力 */
1091                                      byte* authTag, word32 authTagSz,
1092                                      /* 認証する入力データ */
1093                                      const byte* authIn, word32 authInSz);
1094/*!
1095    \ingroup AES
1096
1097    \brief この関数は、「EAX: A Conventional Authenticated-Encryption Mode」（https://eprint.iacr.org/2003/069）で説明されているAES EAX復号と認証を実行します。これは、すべての復号と認証操作を1つの関数呼び出しで実行する「ワンショット」APIです。ゼロ以外のエラーコードが返された場合、出力データは未定義です。ただし、呼び出し元は平文データの漏洩を防ぐために、無条件に出力バッファをゼロ化する必要があります。
1098
1099    \return 0 復号に成功した場合
1100    \return BAD_FUNC_ARG 入力または出力バッファがNULLの場合に返されます。また、キーサイズが有効なAESキーサイズ（16、24、または32バイト）でない場合にも返されます
1101    \return AES_EAX_AUTH_E 認証タグが提供された認証コードベクトル \c authTag と一致しない場合
1102    \return other AESまたはCMAC操作が失敗した場合に返されるその他の負のエラー値。
1103
1104    \param [in] key 使用するキーを含むバイトバッファ
1105    \param [in] keySz キーバッファの長さ（バイト単位）
1106    \param [out] out 平文を保持するバッファ。入力暗号文バッファと同じ長さである必要があります
1107    \param [in] in 復号する暗号文バッファ
1108    \param [in] inSz 暗号文バッファの長さ
1109    \param [in] nonce EAX操作に使用する暗号ナンス
1110    \param [in] nonceSz nonceバッファの長さ（バイト単位）
1111    \param [in] authTag データの真正性をチェックするために照合する認証タグを保持するバッファ
1112    \param [in] authTagSz 入力認証タグの長さ
1113    \param [in] authIn 認証する入力データを含むバッファへのポインタ
1114    \param [in] authInSz 入力認証データの長さ
1115
1116    _Example_
1117    \code
1118    byte key[] = { 32、48、または64バイトのキー };
1119    byte nonce[] = {0x04, 0x5, 0x6};
1120    byte cipherText[] = {0xDE, 0xAD, 0xBE, 0xEF};
1121    byte authIn[] = {0x01, 0x2, 0x3};
1122
1123    byte plainText[sizeof(cipherText)]; // 出力平文
1124    byte authTag[length, up to AES_BLOCK_SIZE]; // 出力authTag
1125
1126    if (wc_AesEaxDecrypt(key, sizeof(key),
1127                         cipherText, plainText, sizeof(plainText),
1128                         nonce, sizeof(nonce),
1129                         authTag, sizeof(authTag),
1130                         authIn, sizeof(authIn)) != 0) {
1131        // 暗号化に失敗
1132    }
1133
1134    \endcode
1135
1136    \sa wc_AesEaxEncryptAuth
1137
1138*/
1139WOLFSSL_API int  wc_AesEaxDecryptAuth(const byte* key, word32 keySz, byte* out,
1140                                      const byte* in, word32 inSz,
1141                                      const byte* nonce, word32 nonceSz,
1142                                      /* 検証する認証タグ */
1143                                      const byte* authTag, word32 authTagSz,
1144                                      /* 認証する入力データ */
1145                                      const byte* authIn, word32 authInSz);
1146
1147/*!
1148    \ingroup AES
1149    \brief この関数は、認証付き暗号化または復号で使用するAesEaxオブジェクトを初期化します。この関数は、AES EAX増分APIのいずれかと使用する前に、AesEaxオブジェクトに対して呼び出す必要があります。ワンショットEAX API関数を使用する場合は呼び出す必要はありません。この関数で初期化されたすべてのAesEaxインスタンスは、インスタンスの使用が完了したらwc_AesEaxFree()の呼び出しで解放する必要があります。
1150
1151    \return 0 成功した場合
1152    \return error code 失敗した場合のエラーコード
1153
1154    \param eax AEAD操作のコンテキストを保持するAES EAX構造体
1155    \param key 暗号化と復号のための16、24、または32バイトの秘密鍵
1156    \param keySz 提供されたキーの長さ（バイト単位）
1157    \param nonce EAX操作に使用する暗号ナンス
1158    \param nonceSz nonceバッファの長さ（バイト単位）
1159    \param authIn （オプション）認証ストリームに追加する入力データ
1160    使用しない場合、この引数はNULLである必要があります
1161    \param authInSz 入力認証データのサイズ（バイト単位）
1162
1163    _Example_
1164    \code
1165    AesEax eax;
1166    key[]   = { 16、24、または32バイト長のキー };
1167    nonce[] = { 任意の長さのnonce };
1168    authIn[] = { 認証ストリームに追加するデータ };
1169    plainText[] = {暗号化する平文データ};
1170
1171    cipherText[sizeof(plainText)]; // cipherTextを保持するバッファ
1172    authTag[length, up to AES_BLOCK_SIZE]; // 計算された認証データを保持するバッファ
1173
1174    AesEax eax;
1175
1176    if ((ret = wc_AesEaxInit(eax,
1177                             key, keySz,
1178                             nonce, nonceSz,
1179                             authIn, authInSz)) != 0) {
1180        goto cleanup;
1181    }
1182
1183    // さらに認証データを追加したい場合は、この時点で提供できます
1184    // そうでない場合は、authInパラメータにNULLを使用し、authInサイズは0です
1185    if ((ret = wc_AesEaxEncryptUpdate(eax,
1186                                      cipherText, plainText, sizeof(plainText),
1187                                      NULL, 0)) != 0) {
1188        goto cleanup;
1189    }
1190
1191    if ((ret = wc_AesEaxEncryptFinal(eax, authTag, sizeof(authTag))) != 0) {
1192        goto cleanup;
1193    }
1194
1195    cleanup:
1196        wc_AesEaxFree(eax);
1197    \endcode
1198
1199    \sa wc_AesEaxEncryptUpdate
1200    \sa wc_AesEaxDecryptUpdate
1201    \sa wc_AesEaxAuthDataUpdate
1202    \sa wc_AesEaxEncryptFinal
1203    \sa wc_AesEaxDecryptFinal
1204    \sa wc_AesEaxFree
1205
1206*/
1207WOLFSSL_API int  wc_AesEaxInit(AesEax* eax,
1208                               const byte* key, word32 keySz,
1209                               const byte* nonce, word32 nonceSz,
1210                               const byte* authIn, word32 authInSz);
1211
1212/*!
1213    \ingroup AES
1214    \brief この関数は、AES EAXを使用して入力データを暗号化し、オプションで認証ストリームにさらに入力データを追加します。\c eax は、\ref wc_AesEaxInit の呼び出しで事前に初期化されている必要があります。
1215
1216    \return 0 成功した場合
1217    \return error code 失敗した場合のエラーコード
1218
1219    \param [in] eax AEAD操作のコンテキストを保持するAES EAX構造体
1220    \param [out] out 暗号文を保持する出力バッファ
1221    \param [in] in 暗号化する平文を保持する入力バッファ
1222    \param [in] inSz 入力データバッファのサイズ（バイト単位）
1223    \param [in] authIn （オプション）認証ストリームに追加する入力データ
1224    使用しない場合、この引数はNULLである必要があります
1225    \param [in] authInSz 入力認証データのサイズ（バイト単位）
1226
1227    _Example_
1228    \code
1229    AesEax eax;
1230    key[]   = { 16、24、または32バイト長のキー };
1231    nonce[] = { 任意の長さのnonce };
1232    authIn[] = { 認証ストリームに追加するデータ };
1233    plainText[] = {暗号化する平文データ};
1234
1235    cipherText[sizeof(plainText)]; // cipherTextを保持するバッファ
1236    authTag[length, up to AES_BLOCK_SIZE]; // 計算された認証データを保持するバッファ
1237
1238    AesEax eax;
1239
1240    if ((ret = wc_AesEaxInit(eax,
1241                             key, keySz,
1242                             nonce, nonceSz,
1243                             authIn, authInSz)) != 0) {
1244        goto cleanup;
1245    }
1246
1247    // さらに認証データを追加したい場合は、この時点で提供できます
1248    // そうでない場合は、authInパラメータにNULLを使用し、authInSzは0です
1249    if ((ret = wc_AesEaxEncryptUpdate(eax,
1250                                      cipherText, plainText, sizeof(plainText),
1251                                      NULL, 0)) != 0) {
1252        goto cleanup;
1253    }
1254
1255    if ((ret = wc_AesEaxEncryptFinal(eax, authTag, sizeof(authTag))) != 0) {
1256        goto cleanup;
1257    }
1258
1259    cleanup:
1260        wc_AesEaxFree(eax);
1261    \endcode
1262
1263    \sa wc_AesEaxInit
1264    \sa wc_AesEaxDecryptUpdate
1265    \sa wc_AesEaxAuthDataUpdate
1266    \sa wc_AesEaxEncryptFinal
1267    \sa wc_AesEaxDecryptFinal
1268    \sa wc_AesEaxFree
1269
1270*/
1271WOLFSSL_API int  wc_AesEaxEncryptUpdate(AesEax* eax, byte* out,
1272                                        const byte* in, word32 inSz,
1273                                        const byte* authIn, word32 authInSz);
1274
1275/*!
1276    \ingroup AES
1277    \brief この関数は、AES EAXを使用して入力データを復号し、オプションで認証ストリームにさらに入力データを追加します。\c eax は、\ref wc_AesEaxInit の呼び出しで事前に初期化されている必要があります。
1278
1279    \return 0 成功した場合
1280    \return error code 失敗した場合のエラーコード
1281
1282    \param [in] eax AEAD操作のコンテキストを保持するAES EAX構造体
1283    \param [out] out 復号された平文を保持する出力バッファ
1284    \param [in] in 暗号文を保持する入力バッファ
1285    \param [in] inSz 入力データバッファのサイズ（バイト単位）
1286    \param [in] authIn （オプション）認証ストリームに追加する入力データ
1287    使用しない場合、この引数はNULLである必要があります
1288    \param [in] authInSz 入力認証データのサイズ（バイト単位）
1289
1290
1291    _Example_
1292    \code
1293    AesEax eax;
1294    key[]   = { 16、24、または32バイト長のキー };
1295    nonce[] = { 任意の長さのnonce };
1296    authIn[] = { 認証ストリームに追加するデータ };
1297    cipherText[] = {暗号化されたデータ};
1298
1299    plainText[sizeof(cipherText)]; // 復号されたデータを保持するバッファ
1300    // 認証タグは、暗号化AEAD操作によって別の場所で生成されます
1301    authTag[length, up to AES_BLOCK_SIZE] = { 認証タグ };
1302
1303    AesEax eax;
1304
1305    if ((ret = wc_AesEaxInit(eax,
1306                             key, keySz,
1307                             nonce, nonceSz,
1308                             authIn, authInSz)) != 0) {
1309        goto cleanup;
1310    }
1311
1312    // さらに認証データを追加したい場合は、この時点で提供できます
1313    // そうでない場合は、authInパラメータにNULLを使用し、authInSzは0です
1314    if ((ret = wc_AesEaxDecryptUpdate(eax,
1315                                      plainText, cipherText, sizeof(cipherText),
1316                                      NULL, 0)) != 0) {
1317        goto cleanup;
1318    }
1319
1320    if ((ret = wc_AesEaxDecryptFinal(eax, authTag, sizeof(authTag))) != 0) {
1321        goto cleanup;
1322    }
1323
1324    cleanup:
1325        wc_AesEaxFree(eax);
1326    \endcode
1327
1328    \sa wc_AesEaxInit
1329    \sa wc_AesEaxEncryptUpdate
1330    \sa wc_AesEaxAuthDataUpdate
1331    \sa wc_AesEaxEncryptFinal
1332    \sa wc_AesEaxDecryptFinal
1333    \sa wc_AesEaxFree
1334
1335*/
1336WOLFSSL_API int  wc_AesEaxDecryptUpdate(AesEax* eax, byte* out,
1337                                        const byte* in, word32 inSz,
1338                                        const byte* authIn, word32 authInSz);
1339/*!
1340    \ingroup AES
1341    \brief この関数は、認証ストリームに入力データを追加します。\c eax は、\ref wc_AesEaxInit の呼び出しで事前に初期化されている必要があります。
1342
1343    \return 0 成功した場合
1344    \return error code 失敗した場合のエラーコード
1345
1346    \param eax AEAD操作のコンテキストを保持するAES EAX構造体
1347    \param authIn 認証ストリームに追加する入力データ
1348    \param authInSz 入力認証データのサイズ（バイト単位）
1349
1350    _Example_
1351    \code
1352    AesEax eax;
1353    key[]   = { 16、24、または32バイト長のキー };
1354    nonce[] = { 任意の長さのnonce };
1355    authIn[] = { 認証ストリームに追加するデータ };
1356    cipherText[] = {暗号化されたデータ};
1357
1358    plainText[sizeof(cipherText)]; // 復号されたデータを保持するバッファ
1359    // 認証タグは、暗号化AEAD操作によって別の場所で生成されます
1360    authTag[length, up to AES_BLOCK_SIZE] = { 認証タグ };
1361
1362    AesEax eax;
1363
1364    // ここでは追加する認証データなし
1365    if ((ret = wc_AesEaxInit(eax,
1366                             key, keySz,
1367                             nonce, nonceSz,
1368                             NULL, 0)) != 0) {
1369        goto cleanup;
1370    }
1371
1372    // ここでは追加する認証データなし、後でwc_AesEaxAuthDataUpdateで追加
1373    if ((ret = wc_AesEaxDecryptUpdate(eax,
1374                                      plainText, cipherText, sizeof(cipherText),
1375                                      NULL, 0)) != 0) {
1376        goto cleanup;
1377    }
1378
1379    if ((ret = wc_AesEaxAuthDataUpdate(eax, authIn, sizeof(authIn))) != 0) {
1380        goto cleanup;
1381    }
1382
1383    if ((ret = wc_AesEaxDecryptFinal(eax, authTag, sizeof(authTag))) != 0) {
1384        goto cleanup;
1385    }
1386
1387    cleanup:
1388        wc_AesEaxFree(eax);
1389    \endcode
1390
1391    \sa wc_AesEaxInit
1392    \sa wc_AesEaxEncryptUpdate
1393    \sa wc_AesEaxDecryptUpdate
1394    \sa wc_AesEaxEncryptFinal
1395    \sa wc_AesEaxDecryptFinal
1396    \sa wc_AesEaxFree
1397
1398*/
1399WOLFSSL_API int  wc_AesEaxAuthDataUpdate(AesEax* eax,
1400                                       const byte* authIn, word32 authInSz);
1401
1402/*!
1403    \ingroup AES
1404    \brief この関数は、暗号化AEAD操作を完了し、現在の認証ストリームに対して認証タグを生成します。\c eax は、\ref wc_AesEaxInit の呼び出しで事前に初期化されている必要があります。\c AesEax コンテキスト構造体の使用が完了したら、\ref wc_AesEaxFree を使用して必ず解放してください。
1405
1406    \return 0 成功した場合
1407    \return error code 失敗した場合のエラーコード
1408
1409    \param eax AEAD操作のコンテキストを保持するAES EAX構造体
1410    \param authTag[out] 計算された認証タグを保持するバッファ
1411    \param authTagSz \c authTag のサイズ（バイト単位）
1412
1413    _Example_
1414    \code
1415    AesEax eax;
1416    key[]   = { 16、24、または32バイト長のキー };
1417    nonce[] = { 任意の長さのnonce };
1418    authIn[] = { 認証ストリームに追加するデータ };
1419    plainText[] = {暗号化する平文データ};
1420    cipherText[sizeof(plainText)]; // cipherTextを保持するバッファ
1421    authTag[length, up to AES_BLOCK_SIZE]; // 計算された認証データを保持するバッファ
1422
1423    AesEax eax;
1424
1425    if ((ret = wc_AesEaxInit(eax,
1426                             key, keySz,
1427                             nonce, nonceSz,
1428                             authIn, authInSz)) != 0) {
1429        goto cleanup;
1430    }
1431
1432    // さらに認証データを追加したい場合は、この時点で提供できます
1433    // そうでない場合は、authInパラメータにNULLを使用し、authInSzは0です
1434    if ((ret = wc_AesEaxEncryptUpdate(eax,
1435                                      cipherText, plainText, sizeof(plainText),
1436                                      NULL, 0)) != 0) {
1437        goto cleanup;
1438    }
1439
1440    if ((ret = wc_AesEaxEncryptFinal(eax, authTag, sizeof(authTag))) != 0) {
1441        goto cleanup;
1442    }
1443
1444    cleanup:
1445        wc_AesEaxFree(eax);
1446    \endcode
1447
1448    \sa wc_AesEaxInit
1449    \sa wc_AesEaxEncryptUpdate
1450    \sa wc_AesEaxDecryptUpdate
1451    \sa wc_AesEaxAuthDataUpdate
1452    \sa wc_AesEaxDecryptFinal
1453    \sa wc_AesEaxFree
1454
1455*/
1456WOLFSSL_API int wc_AesEaxEncryptFinal(AesEax* eax,
1457                                      byte* authTag, word32 authTagSz);
1458
1459/*!
1460    \ingroup AES
1461    \brief この関数は、復号AEAD操作を完了し、認証タグの計算を完了して、ユーザが提供したタグに対してその有効性をチェックします。\c eax は、\ref wc_AesEaxInit の呼び出しで事前に初期化されている必要があります。\c AesEax コンテキスト構造体の使用が完了したら、\ref wc_AesEaxFree を使用して必ず解放してください。
1462
1463    \return 0 データが正常に認証された場合
1464    \return AES_EAX_AUTH_E 認証タグが提供された認証コードベクトル \c authIn と一致しない場合
1465    \return other error code 失敗した場合のその他のエラーコード
1466
1467    \param eax AEAD操作のコンテキストを保持するAES EAX構造体
1468    \param authIn 計算された認証タグと照合するための入力認証タグ
1469    \param authInSz \c authIn のサイズ（バイト単位）
1470
1471    _Example_
1472    \code
1473    AesEax eax;
1474    key[]   = { 16、24、または32バイト長のキー };
1475    nonce[] = { 任意の長さのnonce };
1476    authIn[] = { 認証ストリームに追加するデータ };
1477    cipherText[] = {暗号化されたデータ};
1478
1479    plainText[sizeof(cipherText)]; // 復号されたデータを保持するバッファ
1480    // 認証タグは、暗号化AEAD操作によって別の場所で生成されます
1481    authTag[length, up to AES_BLOCK_SIZE] = { 認証タグ };
1482
1483    AesEax eax;
1484
1485    if ((ret = wc_AesEaxInit(eax,
1486                             key, keySz,
1487                             nonce, nonceSz,
1488                             authIn, authInSz)) != 0) {
1489        goto cleanup;
1490    }
1491
1492    // さらに認証データを追加したい場合は、この時点で提供できます
1493    // そうでない場合は、authInパラメータにNULLを使用し、authInSzは0です
1494    if ((ret = wc_AesEaxDecryptUpdate(eax,
1495                                      plainText, cipherText, sizeof(cipherText),
1496                                      NULL, 0)) != 0) {
1497        goto cleanup;
1498    }
1499
1500    if ((ret = wc_AesEaxDecryptFinal(eax, authTag, sizeof(authTag))) != 0) {
1501        goto cleanup;
1502    }
1503
1504    cleanup:
1505        wc_AesEaxFree(eax);
1506    \endcode
1507
1508    \sa wc_AesEaxInit
1509    \sa wc_AesEaxEncryptUpdate
1510    \sa wc_AesEaxDecryptUpdate
1511    \sa wc_AesEaxAuthDataUpdate
1512    \sa wc_AesEaxEncryptFinal
1513    \sa wc_AesEaxFree
1514
1515*/
1516WOLFSSL_API int wc_AesEaxDecryptFinal(AesEax* eax,
1517                                      const byte* authIn, word32 authInSz);
1518/*!
1519    \ingroup AES
1520
1521    \brief この関数は、AesEaxラッパー構造体内のAesインスタンスによって使用されるリソース、特にキーを解放します。wc_AesEaxInitで初期化された後、すべての必要なEAX操作が完了した時点でAesEax構造体に対して呼び出す必要があります。
1522
1523    \return 0 成功
1524
1525    \param eax 解放するAES EAXインスタンス
1526
1527    _Example_
1528    \code
1529    AesEax eax;
1530
1531    if(wc_AesEaxInit(eax, key, keySz, nonce, nonceSz, authIn, authInSz) != 0) {
1532        // エラーを処理し、その後解放
1533        wc_AesEaxFree(&eax);
1534    }
1535    \endcode
1536
1537    \sa wc_AesEaxInit
1538    \sa wc_AesEaxEncryptUpdate
1539    \sa wc_AesEaxDecryptUpdate
1540    \sa wc_AesEaxAuthDataUpdate
1541    \sa wc_AesEaxEncryptFinal
1542    \sa wc_AesEaxDecryptFinal
1543*/
1544WOLFSSL_API int wc_AesEaxFree(AesEax* eax);
1545
1546/*!
1547    \ingroup AES
1548    \brief この関数は、CTSモードを使用してAES暗号化を実行します。これは、すべての操作を1回の呼び出しで処理するワンショットAPIです。
1549
1550    \return 0 暗号化に成功した場合。
1551    \return BAD_FUNC_ARG 入力引数が無効な場合。
1552    \return other negative error codes 暗号化失敗のためのその他の負のエラーコード。
1553
1554    \param [in] key 暗号化に使用されるAESキーへのポインタ。
1555    \param [in] keySz AESキーのサイズ（バイト単位）（16、24、または32バイト）。
1556    \param [out] out 暗号化された暗号文を保持するバッファ。少なくとも入力と同じサイズである必要があります。
1557    \param [in] in 暗号化する平文入力データへのポインタ。
1558    \param [in] inSz 平文入力データのサイズ（バイト単位）。
1559    \param [in] iv 暗号化に使用される初期化ベクトル（IV）へのポインタ。16バイトである必要があります。
1560
1561    _Example_
1562    \code
1563        byte key[16] = { 0 };
1564        byte iv[16] = { 0 };
1565        byte plaintext[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
1566        byte ciphertext[sizeof(plaintext)];
1567
1568        int ret = wc_AesCtsEncrypt(key, sizeof(key), ciphertext, plaintext,
1569            sizeof(plaintext), iv);
1570        if (ret != 0) {
1571        // 暗号化エラーを処理
1572    }
1573    \endcode
1574
1575    \sa wc_AesCtsDecrypt
1576*/
1577int wc_AesCtsEncrypt(const byte* key, word32 keySz, byte* out,
1578                     const byte* in, word32 inSz,
1579                     const byte* iv);
1580
1581/*!
1582    \ingroup AES
1583    \brief この関数は、CTSモードを使用してAES暗号化を実行します。これは、すべての操作を1回の呼び出しで処理するワンショットAPIです。
1584
1585    \return 0 暗号化に成功した場合。
1586    \return BAD_FUNC_ARG 入力引数が無効な場合。
1587    \return other negative error codes 暗号化失敗のためのその他の負のエラーコード。
1588
1589    \param [in] key 暗号化に使用されるAESキーへのポインタ。
1590    \param [in] keySz AESキーのサイズ（バイト単位）（16、24、または32バイト）。
1591    \param [out] out 暗号化された暗号文を保持するバッファ。少なくとも入力平文と同じサイズである必要があります。
1592    \param [in] in 暗号化する平文入力データへのポインタ。
1593    \param [in] inSz 平文入力データのサイズ（バイト単位）。
1594    \param [in] iv 暗号化に使用される初期化ベクトル（IV）へのポインタ。16バイトである必要があります。
1595    _Example_
1596    \code
1597        byte key[16] = { 0 };
1598        byte iv[16] = { 0 };
1599        byte plaintext[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
1600        byte ciphertext[sizeof(plaintext)];
1601        int ret = wc_AesCtsEncrypt(key, sizeof(key), ciphertext, plaintext,
1602                                   sizeof(plaintext), iv);
1603        if (ret != 0) {
1604            // 暗号化エラーを処理
1605        }
1606    \endcode
1607    \sa wc_AesCtsDecrypt
1608*/
1609int wc_AesCtsEncrypt(const byte* key, word32 keySz, byte* out,
1610                     const byte* in, word32 inSz,
1611                     const byte* iv);
1612
1613/*!
1614    \ingroup AES
1615    \brief この関数は、CTSモードを使用してAES復号を実行します。これは、すべての操作を1回の呼び出しで処理するワンショットAPIです。
1616    \return 0 復号に成功した場合。
1617    \return BAD_FUNC_ARG 入力引数が無効な場合。
1618    \return other negative error codes 復号失敗のためのその他の負のエラーコード。
1619    \param [in] key 復号に使用されるAESキーへのポインタ。
1620    \param [in] keySz AESキーのサイズ（バイト単位）（16、24、または32バイト）。
1621    \param [out] out 復号された平文を保持するバッファ。少なくとも入力暗号文と同じサイズである必要があります。
1622    \param [in] in 復号する暗号文入力データへのポインタ。
1623    \param [in] inSz 暗号文入力データのサイズ（バイト単位）。
1624    \param [in] iv 復号に使用される初期化ベクトル（IV）へのポインタ。16バイトである必要があります。
1625    _Example_
1626    \code
1627        byte key[16] = { 0 };
1628        byte iv[16] = { 0 };
1629        byte ciphertext[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
1630        byte plaintext[sizeof(ciphertext)];
1631        int ret = wc_AesCtsDecrypt(key, sizeof(key), plaintext, ciphertext,
1632                                   sizeof(ciphertext), iv);
1633        if (ret != 0) {
1634            // 復号エラーを処理
1635        }
1636    \endcode
1637    \sa wc_AesCtsEncrypt
1638*/
1639int wc_AesCtsDecrypt(const byte* key, word32 keySz, byte* out,
1640                     const byte* in, word32 inSz,
1641                     const byte* iv);
1642
1643/*!
1644    \ingroup AES
1645    \brief この関数は、AES CTS暗号化の更新ステップを実行します。平文のチャンクを処理し、中間データを保存します。
1646    \return 0 処理に成功した場合。
1647    \return BAD_FUNC_ARG 入力引数が無効な場合。
1648    \param [in] aes 操作のコンテキストを保持するAes構造体へのポインタ。
1649    \param [out] out 暗号化された暗号文を保持するバッファ。この更新ステップからの出力を保存するのに十分な大きさである必要があります。
1650    \param [out] outSz \c out バッファに書き込まれた出力データのサイズ（バイト単位）。入力時には、\c out バッファに書き込むことができる最大バイト数を含める必要があります。
1651    \param [in] in 暗号化する平文入力データへのポインタ。
1652    \param [in] inSz 平文入力データのサイズ（バイト単位）。
1653    _Example_
1654    \code
1655        Aes aes;
1656        wc_AesInit(&aes, NULL, INVALID_DEVID);
1657        byte key[16] = { 0 };
1658        byte iv[16] = { 0 };
1659        byte plaintext[] = { ... };
1660        byte ciphertext[sizeof(plaintext)];
1661        word32 outSz = sizeof(ciphertext);
1662        wc_AesSetKey(&aes, key, sizeof(key), iv, AES_ENCRYPTION);
1663        int ret = wc_AesCtsEncryptUpdate(&aes, ciphertext, &outSz, plaintext, sizeof(plaintext));
1664        if (ret != 0) {
1665            // エラーを処理
1666        }
1667        wc_AesFree(&aes);
1668    \endcode
1669    \sa wc_AesCtsDecryptUpdate
1670*/
1671int wc_AesCtsEncryptUpdate(Aes* aes, byte* out, word32* outSz,
1672                           const byte* in, word32 inSz);
1673
1674/*!
1675    \ingroup AES
1676    \brief この関数は、AES CTS暗号化操作を完了します。残りの平文を処理し、暗号化を完了します。
1677    \return 0 暗号化の完了に成功した場合。
1678    \return BAD_FUNC_ARG 入力引数が無効な場合。
1679    \param [in] aes 操作のコンテキストを保持するAes構造体へのポインタ。
1680    \param [out] out 最終的な暗号化された暗号文を保持するバッファ。この最終ステップから残りの暗号文を保存するのに十分な大きさである必要があります。
1681    \param [out] outSz \c out バッファに書き込まれた出力データのサイズ（バイト単位）。入力時には、\c out バッファに書き込むことができる最大バイト数を含める必要があります。
1682    _Example_
1683    \code
1684        Aes aes;
1685        wc_AesInit(&aes, NULL, INVALID_DEVID);
1686        byte key[16] = { 0 };
1687        byte iv[16] = { 0 };
1688        byte plaintext[] = { ... };
1689        byte ciphertext[sizeof(plaintext)];
1690        word32 outSz = sizeof(ciphertext);
1691        wc_AesSetKey(&aes, key, sizeof(key), iv, AES_ENCRYPTION);
1692        // wc_AesCtsEncryptUpdateを使用して必要な更新ステップを実行
1693        int ret = wc_AesCtsEncryptFinal(&aes, ciphertext, &outSz);
1694        if (ret != 0) {
1695            // エラーを処理
1696        }
1697        wc_AesFree(&aes);
1698    \endcode
1699    \sa wc_AesCtsDecryptFinal
1700*/
1701int wc_AesCtsEncryptFinal(Aes* aes, byte* out, word32* outSz);
1702
1703/*!
1704    \ingroup AES
1705    \brief この関数は、AES CTS復号の更新ステップを実行します。暗号文のチャンクを処理し、中間データを保存します。
1706    \return 0 処理に成功した場合。
1707    \return BAD_FUNC_ARG 入力引数が無効な場合。
1708    \param [in] aes 操作のコンテキストを保持するAes構造体へのポインタ。
1709    \param [out] out 復号された平文を保持するバッファ。この更新ステップからの出力を保存するのに十分な大きさである必要があります。
1710    \param [out] outSz \c out バッファに書き込まれた出力データのサイズ（バイト単位）。入力時には、\c out バッファに書き込むことができる最大バイト数を含める必要があります。
1711    \param [in] in 復号する暗号文入力データへのポインタ。
1712    \param [in] inSz 暗号文入力データのサイズ（バイト単位）。
1713    _Example_
1714    \code
1715        Aes aes;
1716        wc_AesInit(&aes, NULL, INVALID_DEVID);
1717        byte key[16] = { 0 };
1718        byte iv[16] = { 0 };
1719        byte ciphertext[] = { ... };
1720        byte plaintext[sizeof(ciphertext)];
1721        word32 outSz = sizeof(plaintext);
1722        wc_AesSetKey(&aes, key, sizeof(key), iv, AES_DECRYPTION);
1723        int ret = wc_AesCtsDecryptUpdate(&aes, plaintext, &outSz, ciphertext, sizeof(ciphertext));
1724        if (ret != 0) {
1725            // エラーを処理
1726        }
1727        wc_AesFree(&aes);
1728    \endcode
1729    \sa wc_AesCtsEncryptUpdate
1730*/
1731int wc_AesCtsDecryptUpdate(Aes* aes, byte* out, word32* outSz,
1732                           const byte* in, word32 inSz);
1733
1734/*!
1735    \ingroup AES
1736    \brief この関数は、AES CTS復号操作を完了します。残りの暗号文を処理し、復号を完了します。
1737    \return 0 復号の完了に成功した場合。
1738    \return BAD_FUNC_ARG 入力引数が無効な場合。
1739    \param [in] aes 操作のコンテキストを保持するAes構造体へのポインタ。
1740    \param [out] out 最終的な復号された平文を保持するバッファ。この最終ステップから残りの平文を保存するのに十分な大きさである必要があります。
1741    \param [out] outSz \c out バッファに書き込まれた出力データのサイズ（バイト単位）。入力時には、\c out バッファに書き込むことができる最大バイト数を含める必要があります。
1742    _Example_
1743    \code
1744        Aes aes;
1745        wc_AesInit(&aes, NULL, INVALID_DEVID);
1746        byte key[16] = { 0 };
1747        byte iv[16] = { 0 };
1748        byte ciphertext[] = { ... };
1749        byte plaintext[sizeof(ciphertext)];
1750        word32 outSz = sizeof(plaintext);
1751        wc_AesSetKey(&aes, key, sizeof(key), iv, AES_DECRYPTION);
1752        // wc_AesCtsDecryptUpdateを使用して必要な更新ステップを実行
1753        int ret = wc_AesCtsDecryptFinal(&aes, plaintext, &outSz);
1754        if (ret != 0) {
1755            // エラーを処理
1756        }
1757        wc_AesFree(&aes);
1758    \endcode
1759    \sa wc_AesCtsEncryptFinal
1760*/
1761int wc_AesCtsDecryptFinal(Aes* aes, byte* out, word32* outSz);