luna - wolfssl/doc/dox_comments/header

   1/*!
   2    \ingroup SHA
   3
   4    \brief この関数はSHA3-224を初期化します。これはwc_Sha3_224Hashによって自動的に呼び出されます。
   5
   6    \return 0 初期化に成功した場合に返されます
   7
   8    \param sha3 暗号化に使用するsha3構造体へのポインタ
   9
  10    _Example_
  11    \code
  12    wc_Sha3 sha3[1];
  13    if ((ret = wc_InitSha3_224(sha3, NULL, INVALID_DEVID)) != 0) {
  14        WOLFSSL_MSG("wc_InitSha3_224 failed");
  15    }
  16    else {
  17        wc_Sha3_224_Update(sha3, data, len);
  18        wc_Sha3_224_Final(sha3, hash);
  19    }
  20    \endcode
  21
  22    \sa wc_Sha3_224Hash
  23    \sa wc_Sha3_224_Update
  24    \sa wc_Sha3_224_Final
  25*/
  26int wc_InitSha3_224(wc_Sha3* sha3, void* heap, int devId);
  27
  28/*!
  29    \ingroup SHA
  30
  31    \brief 長さlenのバイト配列を継続的にハッシュ化するために呼び出すことができます。
  32
  33    \return 0 ダイジェストへのデータの追加に成功した場合に返されます。
  34
  35    \param sha3 暗号化に使用するsha3構造体へのポインタ
  36    \param data ハッシュ化されるデータ
  37    \param len ハッシュ化されるデータの長さ
  38
  39    _Example_
  40    \code
  41    wc_Sha3 sha3[1];
  42    byte data[] = { ハッシュ化されるデータ };
  43    word32 len = sizeof(data);
  44
  45    if ((ret = wc_InitSha3_224(sha3, NULL, INVALID_DEVID)) != 0) {
  46       WOLFSSL_MSG("wc_InitSha3_224 failed");
  47    }
  48    else {
  49        wc_Sha3_224_Update(sha3, data, len);
  50        wc_Sha3_224_Final(sha3, hash);
  51    }
  52    \endcode
  53
  54    \sa wc_Sha3_224Hash
  55    \sa wc_Sha3_224_Final
  56    \sa wc_InitSha3_224
  57*/
  58int wc_Sha3_224_Update(wc_Sha3* sha, const byte* data, word32 len);
  59
  60/*!
  61    \ingroup SHA
  62
  63    \brief データのハッシュ化を完了します。結果はhashに格納されます。sha3構造体の状態をリセットします。
  64
  65    \return 0 完了に成功した場合に返されます。
  66
  67    \param sha3 暗号化に使用するsha3構造体へのポインタ
  68    \param hash ハッシュ値を保持するバイト配列。
  69
  70    _Example_
  71    \code
  72    wc_Sha3 sha3[1];
  73    byte data[] = { ハッシュ化されるデータ };
  74    word32 len = sizeof(data);
  75
  76    if ((ret = wc_InitSha3_224(sha3, NULL, INVALID_DEVID)) != 0) {
  77       WOLFSSL_MSG("wc_InitSha3_224 failed");
  78    }
  79    else {
  80       wc_Sha3_224_Update(sha3, data, len);
  81       wc_Sha3_224_Final(sha3, hash);
  82    }
  83    \endcode
  84
  85    \sa wc_Sha3_224Hash
  86    \sa wc_Sha3_224_GetHash
  87    \sa wc_InitSha3_224
  88*/
  89int wc_Sha3_224_Final(wc_Sha3* sha3, byte* hash);
  90
  91/*!
  92    \ingroup SHA
  93
  94    \brief wc_Sha3構造体をリセットします。注：これはWOLFSSL_TI_HASHが定義されている場合のみサポートされます。
  95
  96    \return none 戻り値なし。
  97
  98    \param sha3 解放されるsha3構造体へのポインタ。
  99
 100    _Example_
 101    \code
 102    wc_Sha3 sha3;
 103    byte data[] = { ハッシュ化されるデータ };
 104    word32 len = sizeof(data);
 105
 106    if ((ret = wc_InitSha3_224(&sha3, NULL, INVALID_DEVID)) != 0) {
 107        WOLFSSL_MSG("wc_InitSha3_224 failed");
 108    }
 109    else {
 110        wc_Sha3_224_Update(&sha3, data, len);
 111        wc_Sha3_224_Final(&sha3, hash);
 112        wc_Sha3_224_Free(&sha3);
 113    }
 114    \endcode
 115
 116    \sa wc_InitSha3_224
 117    \sa wc_Sha3_224_Update
 118    \sa wc_Sha3_224_Final
 119*/
 120void wc_Sha3_224_Free(wc_Sha3* sha3);
 121
 122/*!
 123    \ingroup SHA
 124
 125    \brief ハッシュデータを取得します。結果はhashに格納されます。sha3構造体の状態をリセットしません。
 126
 127    \return 0 ハッシュのコピーに成功した場合に返されます。
 128
 129    \param sha3 暗号化に使用するsha3構造体へのポインタ
 130    \param hash ハッシュ値を保持するバイト配列。
 131
 132    _Example_
 133    \code
 134    wc_Sha3 sha3[1];
 135    if ((ret = wc_InitSha3_224(sha3, NULL, INVALID_DEVID)) != 0) {
 136       WOLFSSL_MSG("wc_InitSha3_224 failed");
 137    }
 138    else {
 139       wc_Sha3_224_Update(sha3, data, len);
 140       wc_Sha3_224_GetHash(sha3, hash);
 141    }
 142    \endcode
 143
 144    \sa wc_Sha3_224Hash
 145    \sa wc_Sha3_224_Final
 146    \sa wc_InitSha3_224
 147    \sa wc_Sha3_224_Copy
 148*/
 149int wc_Sha3_224_GetHash(wc_Sha3* sha3, byte* hash);
 150
 151/*!
 152    \ingroup SHA
 153
 154    \brief ハッシュの状態をコピーします。
 155
 156    \return 0 コピーに成功した場合に返されます。
 157
 158    \param sha3 コピーするsha3構造体へのポインタ
 159    \param dst  コピー先のsha3構造体へのポインタ
 160
 161    _Example_
 162    \code
 163    wc_Sha3 sha3[1];
 164    wc_Sha3 sha3_dup[1];
 165    if ((ret = wc_InitSha3_224(sha3, NULL, INVALID_DEVID)) != 0) {
 166       WOLFSSL_MSG("wc_InitSha3_224 failed");
 167    }
 168    else {
 169       wc_Sha3_224_Update(sha3, data, len);
 170       wc_Sha3_224_Copy(sha3, sha3_dup);
 171    }
 172    \endcode
 173
 174    \sa wc_Sha3_224Hash
 175    \sa wc_Sha3_224_Final
 176    \sa wc_InitSha3_224
 177    \sa wc_Sha3_224_GetHash
 178*/
 179int wc_Sha3_224_Copy(wc_Sha3* sha3, wc_Sha3* dst);
 180
 181/*!
 182    \ingroup SHA
 183
 184    \brief この関数はSHA3-256を初期化します。これはwc_Sha3_256Hashによって自動的に呼び出されます。
 185
 186    \return 0 初期化に成功した場合に返されます
 187
 188    \param sha3 暗号化に使用するsha3構造体へのポインタ
 189
 190    _Example_
 191    \code
 192    wc_Sha3 sha3[1];
 193    if ((ret = wc_InitSha3_256(sha3, NULL, INVALID_DEVID)) != 0) {
 194        WOLFSSL_MSG("wc_InitSha3_256 failed");
 195    }
 196    else {
 197        wc_Sha3_256_Update(sha3, data, len);
 198        wc_Sha3_256_Final(sha3, hash);
 199    }
 200    \endcode
 201
 202    \sa wc_Sha3_256Hash
 203    \sa wc_Sha3_256_Update
 204    \sa wc_Sha3_256_Final
 205*/
 206int wc_InitSha3_256(wc_Sha3* sha3, void* heap, int devId);
 207
 208/*!
 209    \ingroup SHA
 210
 211    \brief 長さlenのバイト配列を継続的にハッシュ化するために呼び出すことができます。
 212
 213    \return 0 ダイジェストへのデータの追加に成功した場合に返されます。
 214
 215    \param sha3 暗号化に使用するsha3構造体へのポインタ
 216    \param data ハッシュ化されるデータ
 217    \param len ハッシュ化されるデータの長さ
 218
 219    _Example_
 220    \code
 221    wc_Sha3 sha3[1];
 222    byte data[] = { ハッシュ化されるデータ };
 223    word32 len = sizeof(data);
 224
 225    if ((ret = wc_InitSha3_256(sha3, NULL, INVALID_DEVID)) != 0) {
 226       WOLFSSL_MSG("wc_InitSha3_256 failed");
 227    }
 228    else {
 229        wc_Sha3_256_Update(sha3, data, len);
 230        wc_Sha3_256_Final(sha3, hash);
 231    }
 232    \endcode
 233
 234    \sa wc_Sha3_256Hash
 235    \sa wc_Sha3_256_Final
 236    \sa wc_InitSha3_256
 237*/
 238int wc_Sha3_256_Update(wc_Sha3* sha, const byte* data, word32 len);
 239
 240/*!
 241    \ingroup SHA
 242
 243    \brief データのハッシュ化を完了します。結果はhashに格納されます。sha3構造体の状態をリセットします。
 244
 245    \return 0 完了に成功した場合に返されます。
 246
 247    \param sha3 暗号化に使用するsha3構造体へのポインタ
 248    \param hash ハッシュ値を保持するバイト配列。
 249
 250    _Example_
 251    \code
 252    wc_Sha3 sha3[1];
 253    byte data[] = { ハッシュ化されるデータ };
 254    word32 len = sizeof(data);
 255
 256    if ((ret = wc_InitSha3_256(sha3, NULL, INVALID_DEVID)) != 0) {
 257       WOLFSSL_MSG("wc_InitSha3_256 failed");
 258    }
 259    else {
 260       wc_Sha3_256_Update(sha3, data, len);
 261       wc_Sha3_256_Final(sha3, hash);
 262    }
 263    \endcode
 264
 265    \sa wc_Sha3_256Hash
 266    \sa wc_Sha3_256_GetHash
 267    \sa wc_InitSha3_256
 268*/
 269int wc_Sha3_256_Final(wc_Sha3* sha3, byte* hash);
 270
 271/*!
 272    \ingroup SHA
 273
 274    \brief wc_Sha3構造体をリセットします。注：これはWOLFSSL_TI_HASHが定義されている場合のみサポートされます。
 275
 276    \return none 戻り値なし。
 277
 278    \param sha3 解放されるsha3構造体へのポインタ。
 279
 280    _Example_
 281    \code
 282    wc_Sha3 sha3;
 283    byte data[] = { ハッシュ化されるデータ };
 284    word32 len = sizeof(data);
 285
 286    if ((ret = wc_InitSha3_256(&sha3, NULL, INVALID_DEVID)) != 0) {
 287        WOLFSSL_MSG("wc_InitSha3_256 failed");
 288    }
 289    else {
 290        wc_Sha3_256_Update(&sha3, data, len);
 291        wc_Sha3_256_Final(&sha3, hash);
 292        wc_Sha3_256_Free(&sha3);
 293    }
 294    \endcode
 295
 296    \sa wc_InitSha3_256
 297    \sa wc_Sha3_256_Update
 298    \sa wc_Sha3_256_Final
 299*/
 300void wc_Sha3_256_Free(wc_Sha3* sha3);
 301
 302/*!
 303    \ingroup SHA
 304
 305    \brief ハッシュデータを取得します。結果はhashに格納されます。sha3構造体の状態をリセットしません。
 306
 307    \return 0 ハッシュのコピーに成功した場合に返されます。
 308
 309    \param sha3 暗号化に使用するsha3構造体へのポインタ
 310    \param hash ハッシュ値を保持するバイト配列。
 311
 312    _Example_
 313    \code
 314    wc_Sha3 sha3[1];
 315    if ((ret = wc_InitSha3_256(sha3, NULL, INVALID_DEVID)) != 0) {
 316       WOLFSSL_MSG("wc_InitSha3_256 failed");
 317    }
 318    else {
 319       wc_Sha3_256_Update(sha3, data, len);
 320       wc_Sha3_256_GetHash(sha3, hash);
 321    }
 322    \endcode
 323
 324    \sa wc_Sha3_256Hash
 325    \sa wc_Sha3_256_Final
 326    \sa wc_InitSha3_256
 327    \sa wc_Sha3_256_Copy
 328*/
 329int wc_Sha3_256_GetHash(wc_Sha3* sha3, byte* hash);
 330
 331/*!
 332    \ingroup SHA
 333
 334    \brief ハッシュの状態をコピーします。
 335
 336    \return 0 コピーに成功した場合に返されます。
 337
 338    \param sha3 コピーするsha3構造体へのポインタ
 339    \param dst  コピー先のsha3構造体へのポインタ
 340
 341    _Example_
 342    \code
 343    wc_Sha3 sha3[1];
 344    wc_Sha3 sha3_dup[1];
 345    if ((ret = wc_InitSha3_256(sha3, NULL, INVALID_DEVID)) != 0) {
 346       WOLFSSL_MSG("wc_InitSha3_256 failed");
 347    }
 348    else {
 349       wc_Sha3_256_Update(sha3, data, len);
 350       wc_Sha3_256_Copy(sha3, sha3_dup);
 351    }
 352    \endcode
 353
 354    \sa wc_Sha3_256Hash
 355    \sa wc_Sha3_256_Final
 356    \sa wc_InitSha3_256
 357    \sa wc_Sha3_256_GetHash
 358*/
 359int wc_Sha3_256_Copy(wc_Sha3* sha3, wc_Sha3* dst);
 360
 361/*!
 362    \ingroup SHA
 363
 364    \brief この関数はSHA3-384を初期化します。これはwc_Sha3_384Hashによって自動的に呼び出されます。
 365
 366    \return 0 初期化に成功した場合に返されます
 367
 368    \param sha3 暗号化に使用するsha3構造体へのポインタ
 369
 370    _Example_
 371    \code
 372    wc_Sha3 sha3[1];
 373    if ((ret = wc_InitSha3_384(sha3, NULL, INVALID_DEVID)) != 0) {
 374        WOLFSSL_MSG("wc_InitSha3_384 failed");
 375    }
 376    else {
 377        wc_Sha3_384_Update(sha3, data, len);
 378        wc_Sha3_384_Final(sha3, hash);
 379    }
 380    \endcode
 381
 382    \sa wc_Sha3_384Hash
 383    \sa wc_Sha3_384_Update
 384    \sa wc_Sha3_384_Final
 385*/
 386int wc_InitSha3_384(wc_Sha3* sha3, void* heap, int devId);
 387
 388/*!
 389    \ingroup SHA
 390
 391    \brief 長さlenのバイト配列を継続的にハッシュ化するために呼び出すことができます。
 392
 393    \return 0 ダイジェストへのデータの追加に成功した場合に返されます。
 394
 395    \param sha3 暗号化に使用するsha3構造体へのポインタ
 396    \param data ハッシュ化されるデータ
 397    \param len ハッシュ化されるデータの長さ
 398
 399    _Example_
 400    \code
 401    wc_Sha3 sha3[1];
 402    byte data[] = { ハッシュ化されるデータ };
 403    word32 len = sizeof(data);
 404
 405    if ((ret = wc_InitSha3_384(sha3, NULL, INVALID_DEVID)) != 0) {
 406       WOLFSSL_MSG("wc_InitSha3_384 failed");
 407    }
 408    else {
 409        wc_Sha3_384_Update(sha3, data, len);
 410        wc_Sha3_384_Final(sha3, hash);
 411    }
 412    \endcode
 413
 414    \sa wc_Sha3_384Hash
 415    \sa wc_Sha3_384_Final
 416    \sa wc_InitSha3_384
 417*/
 418int wc_Sha3_384_Update(wc_Sha3* sha, const byte* data, word32 len);
 419
 420/*!
 421    \ingroup SHA
 422
 423    \brief データのハッシュ化を完了します。結果はhashに格納されます。sha3構造体の状態をリセットします。
 424
 425    \return 0 完了に成功した場合に返されます。
 426
 427    \param sha3 暗号化に使用するsha3構造体へのポインタ
 428    \param hash ハッシュ値を保持するバイト配列。
 429
 430    _Example_
 431    \code
 432    wc_Sha3 sha3[1];
 433    byte data[] = { ハッシュ化されるデータ };
 434    word32 len = sizeof(data);
 435
 436    if ((ret = wc_InitSha3_384(sha3, NULL, INVALID_DEVID)) != 0) {
 437       WOLFSSL_MSG("wc_InitSha3_384 failed");
 438    }
 439    else {
 440       wc_Sha3_384_Update(sha3, data, len);
 441       wc_Sha3_384_Final(sha3, hash);
 442    }
 443    \endcode
 444
 445    \sa wc_Sha3_384Hash
 446    \sa wc_Sha3_384_GetHash
 447    \sa wc_InitSha3_384
 448*/
 449int wc_Sha3_384_Final(wc_Sha3* sha3, byte* hash);
 450
 451/*!
 452    \ingroup SHA
 453
 454    \brief wc_Sha3構造体をリセットします。注：これはWOLFSSL_TI_HASHが定義されている場合のみサポートされます。
 455
 456    \return none 戻り値なし。
 457
 458    \param sha3 解放されるsha3構造体へのポインタ。
 459
 460    _Example_
 461    \code
 462    wc_Sha3 sha3;
 463    byte data[] = { ハッシュ化されるデータ };
 464    word32 len = sizeof(data);
 465
 466    if ((ret = wc_InitSha3_384(&sha3, NULL, INVALID_DEVID)) != 0) {
 467        WOLFSSL_MSG("wc_InitSha3_384 failed");
 468    }
 469    else {
 470        wc_Sha3_384_Update(&sha3, data, len);
 471        wc_Sha3_384_Final(&sha3, hash);
 472        wc_Sha3_384_Free(&sha3);
 473    }
 474    \endcode
 475
 476    \sa wc_InitSha3_384
 477    \sa wc_Sha3_384_Update
 478    \sa wc_Sha3_384_Final
 479*/
 480void wc_Sha3_384_Free(wc_Sha3* sha3);
 481
 482/*!
 483    \ingroup SHA
 484
 485    \brief ハッシュデータを取得します。結果はhashに格納されます。sha3構造体の状態をリセットしません。
 486
 487    \return 0 ハッシュのコピーに成功した場合に返されます。
 488
 489    \param sha3 暗号化に使用するsha3構造体へのポインタ
 490    \param hash ハッシュ値を保持するバイト配列。
 491
 492    _Example_
 493    \code
 494    wc_Sha3 sha3[1];
 495    if ((ret = wc_InitSha3_384(sha3, NULL, INVALID_DEVID)) != 0) {
 496       WOLFSSL_MSG("wc_InitSha3_38384ailed");
 497    }
 498    else {
 499       wc_Sha3_384_Update(sha3, data, len);
 500       wc_Sha3_384_GetHash(sha3, hash);
 501    }
 502    \endcode
 503
 504    \sa wc_Sha3_384Hash
 505    \sa wc_Sha3_384_Final
 506    \sa wc_InitSha3_384
 507    \sa wc_Sha3_384_Copy
 508*/
 509int wc_Sha3_384_GetHash(wc_Sha3* sha3, byte* hash);
 510
 511/*!
 512    \ingroup SHA
 513
 514    \brief ハッシュの状態をコピーします。
 515
 516    \return 0 コピーに成功した場合に返されます。
 517
 518    \param sha3 コピーするsha3構造体へのポインタ
 519    \param dst  コピー先のsha3構造体へのポインタ
 520
 521    _Example_
 522    \code
 523    wc_Sha3 sha3[1];
 524    wc_Sha3 sha3_dup[1];
 525    if ((ret = wc_InitSha3_384(sha3, NULL, INVALID_DEVID)) != 0) {
 526       WOLFSSL_MSG("wc_InitSha3_384 failed");
 527    }
 528    else {
 529       wc_Sha3_384_Update(sha3, data, len);
 530       wc_Sha3_384_Copy(sha3, sha3_dup);
 531    }
 532    \endcode
 533
 534    \sa wc_Sha3_384Hash
 535    \sa wc_Sha3_384_Final
 536    \sa wc_InitSha3_384
 537    \sa wc_Sha3_384_GetHash
 538*/
 539int wc_Sha3_384_Copy(wc_Sha3* sha3, wc_Sha3* dst);
 540
 541/*!
 542    \ingroup SHA
 543
 544    \brief この関数はSHA3-512を初期化します。これはwc_Sha3_512Hashによって自動的に呼び出されます。
 545
 546    \return 0 初期化に成功した場合に返されます
 547
 548    \param sha3 暗号化に使用するsha3構造体へのポインタ
 549
 550    _Example_
 551    \code
 552    wc_Sha3 sha3[1];
 553    if ((ret = wc_InitSha3_512(sha3, NULL, INVALID_DEVID)) != 0) {
 554        WOLFSSL_MSG("wc_InitSha3_512 failed");
 555    }
 556    else {
 557        wc_Sha3_512_Update(sha3, data, len);
 558        wc_Sha3_512_Final(sha3, hash);
 559    }
 560    \endcode
 561
 562    \sa wc_Sha3_512Hash
 563    \sa wc_Sha3_512_Update
 564    \sa wc_Sha3_512_Final
 565*/
 566int wc_InitSha3_512(wc_Sha3* sha3, void* heap, int devId);
 567
 568/*!
 569    \ingroup SHA
 570
 571    \brief 長さlenのバイト配列を継続的にハッシュ化するために呼び出すことができます。
 572
 573    \return 0 ダイジェストへのデータの追加に成功した場合に返されます。
 574
 575    \param sha3 暗号化に使用するsha3構造体へのポインタ
 576    \param data ハッシュ化されるデータ
 577    \param len ハッシュ化されるデータの長さ
 578
 579    _Example_
 580    \code
 581    wc_Sha3 sha3[1];
 582    byte data[] = { ハッシュ化されるデータ };
 583    word32 len = sizeof(data);
 584
 585    if ((ret = wc_InitSha3_512(sha3, NULL, INVALID_DEVID)) != 0) {
 586       WOLFSSL_MSG("wc_InitSha3_512 failed");
 587    }
 588    else {
 589        wc_Sha3_512_Update(sha3, data, len);
 590        wc_Sha3_512_Final(sha3, hash);
 591    }
 592    \endcode
 593
 594    \sa wc_Sha3_512Hash
 595    \sa wc_Sha3_512_Final
 596    \sa wc_InitSha3_512
 597*/
 598int wc_Sha3_512_Update(wc_Sha3* sha, const byte* data, word32 len);
 599
 600/*!
 601    \ingroup SHA
 602
 603    \brief データのハッシュ化を完了します。結果はhashに格納されます。sha3構造体の状態をリセットします。
 604
 605    \return 0 完了に成功した場合に返されます。
 606
 607    \param sha3 暗号化に使用するsha3構造体へのポインタ
 608    \param hash ハッシュ値を保持するバイト配列。
 609
 610    _Example_
 611    \code
 612    wc_Sha3 sha3[1];
 613    byte data[] = { ハッシュ化されるデータ };
 614    word32 len = sizeof(data);
 615
 616    if ((ret = wc_InitSha3_512(sha3, NULL, INVALID_DEVID)) != 0) {
 617       WOLFSSL_MSG("wc_InitSha3_512 failed");
 618    }
 619    else {
 620       wc_Sha3_512_Update(sha3, data, len);
 621       wc_Sha3_512_Final(sha3, hash);
 622    }
 623    \endcode
 624
 625    \sa wc_Sha3_512Hash
 626    \sa wc_Sha3_512_GetHash
 627    \sa wc_InitSha3_512
 628*/
 629int wc_Sha3_512_Final(wc_Sha3* sha3, byte* hash);
 630
 631/*!
 632    \ingroup SHA
 633
 634    \brief wc_Sha3構造体をリセットします。注：これはWOLFSSL_TI_HASHが定義されている場合のみサポートされます。
 635
 636    \return none 戻り値なし。
 637
 638    \param sha3 解放されるsha3構造体へのポインタ。
 639
 640    _Example_
 641    \code
 642    wc_Sha3 sha3;
 643    byte data[] = { ハッシュ化されるデータ };
 644    word32 len = sizeof(data);
 645
 646    if ((ret = wc_InitSha3_512(&sha3, NULL, INVALID_DEVID)) != 0) {
 647        WOLFSSL_MSG("wc_InitSha3_512 failed");
 648    }
 649    else {
 650        wc_Sha3_512_Update(&sha3, data, len);
 651        wc_Sha3_512_Final(&sha3, hash);
 652        wc_Sha3_512_Free(&sha3);
 653    }
 654    \endcode
 655
 656    \sa wc_InitSha3_512
 657    \sa wc_Sha3_512_Update
 658    \sa wc_Sha3_512_Final
 659*/
 660void wc_Sha3_512_Free(wc_Sha3* sha3);
 661
 662/*!
 663    \ingroup SHA
 664
 665    \brief ハッシュデータを取得します。結果はhashに格納されます。sha3構造体の状態をリセットしません。
 666
 667    \return 0 ハッシュのコピーに成功した場合に返されます。
 668
 669    \param sha3 暗号化に使用するsha3構造体へのポインタ
 670    \param hash ハッシュ値を保持するバイト配列。
 671
 672    _Example_
 673    \code
 674    wc_Sha3 sha3[1];
 675    if ((ret = wc_InitSha3_512(sha3, NULL, INVALID_DEVID)) != 0) {
 676       WOLFSSL_MSG("wc_InitSha3_512 failed");
 677    }
 678    else {
 679       wc_Sha3_512_Update(sha3, data, len);
 680       wc_Sha3_512_GetHash(sha3, hash);
 681    }
 682    \endcode
 683
 684    \sa wc_Sha3_512Hash
 685    \sa wc_Sha3_512_Final
 686    \sa wc_InitSha3_512
 687    \sa wc_Sha3_512_Copy
 688*/
 689int wc_Sha3_512_GetHash(wc_Sha3* sha3, byte* hash);
 690
 691/*!
 692    \ingroup SHA
 693
 694    \brief ハッシュの状態をコピーします。
 695
 696    \return 0 コピーに成功した場合に返されます。
 697
 698    \param sha3 コピーするsha3構造体へのポインタ
 699    \param dst  コピー先のsha3構造体へのポインタ
 700
 701    _Example_
 702    \code
 703    wc_Sha3 sha3[1];
 704    wc_Sha3 sha3_dup[1];
 705    if ((ret = wc_InitSha3_512(sha3, NULL, INVALID_DEVID)) != 0) {
 706       WOLFSSL_MSG("wc_InitSha3_512 failed");
 707    }
 708    else {
 709       wc_Sha3_512_Update(sha3, data, len);
 710       wc_Sha3_512_Copy(sha3, sha3_dup);
 711    }
 712    \endcode
 713
 714    \sa wc_Sha3_512Hash
 715    \sa wc_Sha3_512_Final
 716    \sa wc_InitSha3_512
 717    \sa wc_Sha3_512_GetHash
 718*/
 719int wc_Sha3_512_Copy(wc_Sha3* sha3, wc_Sha3* dst);
 720
 721/*!
 722    \ingroup SHA
 723
 724    \brief この関数はSHAKE-128を初期化します。これはwc_Shake128Hashによって自動的に呼び出されます。
 725
 726    \return 0 初期化に成功した場合に返されます
 727
 728    \param shake 暗号化に使用するshake構造体へのポインタ
 729
 730    _Example_
 731    \code
 732    wc_Shake shake[1];
 733    if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
 734        WOLFSSL_MSG("wc_InitShake128 failed");
 735    }
 736    else {
 737        wc_Shake128_Update(shake, data, len);
 738        wc_Shake128_Final(shake, hash);
 739    }
 740    \endcode
 741
 742    \sa wc_Shake128Hash
 743    \sa wc_Shake128_Update
 744    \sa wc_Shake128_Final
 745*/
 746int wc_InitShake128(wc_Shake* shake, void* heap, int devId);
 747
 748/*!
 749    \ingroup SHA
 750
 751    \brief 長さlenのバイト配列を継続的にハッシュ化するために呼び出すことができます。
 752
 753    \return 0 ダイジェストへのデータの追加に成功した場合に返されます。
 754
 755    \param shake 暗号化に使用するshake構造体へのポインタ
 756    \param data ハッシュ化されるデータ
 757    \param len ハッシュ化されるデータの長さ
 758
 759    _Example_
 760    \code
 761    wc_Shake shake[1];
 762    byte data[] = { ハッシュ化されるデータ };
 763    word32 len = sizeof(data);
 764
 765    if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
 766       WOLFSSL_MSG("wc_InitShake128 failed");
 767    }
 768    else {
 769        wc_Shake128_Update(shake, data, len);
 770        wc_Shake128_Final(shake, hash);
 771    }
 772    \endcode
 773
 774    \sa wc_Shake128Hash
 775    \sa wc_Shake128_Final
 776    \sa wc_InitShake128
 777*/
 778int wc_Shake128_Update(wc_Shake* sha, const byte* data, word32 len);
 779
 780/*!
 781    \ingroup SHA
 782
 783    \brief データのハッシュ化を完了します。結果はhashに格納されます。shake構造体の状態をリセットします。
 784
 785    \return 0 完了に成功した場合に返されます。
 786
 787    \param shake 暗号化に使用するshake構造体へのポインタ
 788    \param hash ハッシュ値を保持するバイト配列。
 789    \param hashLen hashに書き込むバイト数。
 790
 791    _Example_
 792    \code
 793    wc_Shake shake[1];
 794    byte data[] = { ハッシュ化されるデータ };
 795    word32 len = sizeof(data);
 796
 797    if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
 798       WOLFSSL_MSG("wc_InitShake128 failed");
 799    }
 800    else {
 801       wc_Shake128_Update(shake, data, len);
 802       wc_Shake128_Final(shake, hash);
 803    }
 804    \endcode
 805
 806    \sa wc_Shake128Hash
 807    \sa wc_Shake128_GetHash
 808    \sa wc_InitShake128
 809*/
 810int wc_Shake128_Final(wc_Shake* shake, byte* hash, word32 hashLen);
 811
 812/*!
 813    \ingroup SHA
 814
 815    \brief 長さlenの提供されたバイト配列を吸収するために呼び出されます。段階的に呼び出すことはできません。
 816
 817    \return 0 データの吸収に成功した場合に返されます。
 818
 819    \param shake 暗号化に使用するshake構造体へのポインタ
 820    \param data 吸収されるデータ
 821    \param len 吸収されるデータの長さ
 822
 823    _Example_
 824    \code
 825    wc_Shake shake[1];
 826    byte data[] = { ハッシュ化されるデータ };
 827    word32 len = sizeof(data);
 828    byte out[2 * WC_SHA3_128_BLOCK_SIZE];
 829    int blocks = 2;
 830
 831    if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
 832       WOLFSSL_MSG("wc_InitShake128 failed");
 833    }
 834    else {
 835       wc_Shake128_Absorb(shake, data, len);
 836       wc_Shake128_SqueezeBlocks(shake, out, blocks);
 837    }
 838    \endcode
 839
 840    \sa wc_Shake128_SqueezeBlocks
 841    \sa wc_InitShake128
 842*/
 843int wc_Shake128_Absorb(wc_Shake* sha, const byte* data, word32 len);
 844
 845/*!
 846    \ingroup SHA
 847
 848    \brief さらに多くのデータブロックを絞り出します。結果はoutに格納されます。段階的に呼び出すことができます。
 849
 850    \return 0 絞り出しに成功した場合に返されます。
 851
 852    \param shake 暗号化に使用するshake構造体へのポインタ
 853    \param hash 出力を保持するバイト配列。
 854    \param blocks 絞り出すブロックの数。各ブロックはWC_SHA3_128_BLOCK_SIZEバイトの長さです。
 855
 856    _Example_
 857    \code
 858    wc_Shake shake[1];
 859    byte data[] = { ハッシュ化されるデータ };
 860    word32 len = sizeof(data);
 861    byte out[2 * WC_SHA3_128_BLOCK_SIZE];
 862    int blocks = 2;
 863
 864    if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
 865       WOLFSSL_MSG("wc_InitShake128 failed");
 866    }
 867    else {
 868       wc_Shake128_Absorb(shake, data, len);
 869       wc_Shake128_SqueezeBlocks(shake, out, blocks);
 870    }
 871    \endcode
 872
 873    \sa wc_Shake128_Absorb
 874    \sa wc_InitShake128
 875*/
 876int wc_Shake128_SqueezeBlocks(wc_Shake* shake, byte* out, word32 blockCnt);
 877
 878/*!
 879    \ingroup SHA
 880
 881    \brief wc_Shake構造体をリセットします。注：これはWOLFSSL_TI_HASHが定義されている場合のみサポートされます。
 882
 883    \return none 戻り値なし。
 884
 885    \param shake 解放されるshake構造体へのポインタ。
 886
 887    _Example_
 888    \code
 889    wc_Shake shake;
 890    byte data[] = { ハッシュ化されるデータ };
 891    word32 len = sizeof(data);
 892
 893    if ((ret = wc_InitShake128(&shake, NULL, INVALID_DEVID)) != 0) {
 894        WOLFSSL_MSG("wc_InitShake128 failed");
 895    }
 896    else {
 897        wc_Shake128_Update(&shake, data, len);
 898        wc_Shake128_Final(&shake, hash);
 899        wc_Shake128_Free(&shake);
 900    }
 901    \endcode
 902
 903    \sa wc_InitShake128
 904    \sa wc_Shake128_Update
 905    \sa wc_Shake128_Final
 906*/
 907void wc_Shake128_Free(wc_Shake* shake);
 908
 909/*!
 910    \ingroup SHA
 911
 912    \brief ハッシュデータを取得します。結果はhashに格納されます。shake構造体の状態をリセットしません。
 913
 914    \return 0 ハッシュのコピーに成功した場合に返されます。
 915
 916    \param shake 暗号化に使用するshake構造体へのポインタ
 917    \param hash ハッシュ値を保持するバイト配列。
 918
 919    _Example_
 920    \code
 921    wc_Shake shake[1];
 922    if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
 923       WOLFSSL_MSG("wc_InitShake128 failed");
 924    }
 925    else {
 926       wc_Shake128_Update(shake, data, len);
 927       wc_Shake128_GetHash(shake, hash);
 928    }
 929    \endcode
 930
 931    \sa wc_Shake128Hash
 932    \sa wc_Shake128_Final
 933    \sa wc_InitShake128
 934    \sa wc_Shake128_Copy
 935*/
 936int wc_Shake128_GetHash(wc_Shake* shake, byte* hash);
 937
 938/*!
 939    \ingroup SHA
 940
 941    \brief ハッシュの状態をコピーします。
 942
 943    \return 0 コピーに成功した場合に返されます。
 944
 945    \param src コピーするshake構造体へのポインタ
 946    \param dst コピー先のshake構造体へのポインタ
 947
 948    _Example_
 949    \code
 950    wc_Shake shake[1];
 951    wc_Shake shake_dup[1];
 952    if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
 953       WOLFSSL_MSG("wc_InitShake128 failed");
 954    }
 955    else {
 956       wc_Shake128_Update(shake, data, len);
 957       wc_Shake128_Copy(shake, shake_dup);
 958    }
 959    \endcode
 960
 961    \sa wc_Shake128Hash
 962    \sa wc_Shake128_Final
 963    \sa wc_InitShake128
 964    \sa wc_Shake128_GetHash
 965*/
 966int wc_Shake128_Copy(wc_Shake* src, wc_Sha3* dst);
 967
 968/*!
 969    \ingroup SHA
 970
 971    \brief この関数はSHAKE-256を初期化します。これはwc_Shake256Hashによって自動的に呼び出されます。
 972
 973    \return 0 初期化に成功した場合に返されます
 974
 975    \param shake 暗号化に使用するshake構造体へのポインタ
 976
 977    _Example_
 978    \code
 979    wc_Shake shake[1];
 980    if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
 981        WOLFSSL_MSG("wc_InitShake256 failed");
 982    }
 983    else {
 984        wc_Shake256_Update(shake, data, len);
 985        wc_Shake256_Final(shake, hash, sizeof(hash));
 986    }
 987    \endcode
 988
 989    \sa wc_Shake256Hash
 990    \sa wc_Shake256_Update
 991    \sa wc_Shake256_Final
 992*/
 993int wc_InitShake256(wc_Shake* shake, void* heap, int devId);
 994
 995/*!
 996    \ingroup SHA
 997
 998    \brief 長さlenのバイト配列を継続的にハッシュ化するために呼び出すことができます。
 999
1000    \return 0 ダイジェストへのデータの追加に成功した場合に返されます。
1001
1002    \param shake 暗号化に使用するshake構造体へのポインタ
1003    \param data ハッシュ化されるデータ
1004    \param len ハッシュ化されるデータの長さ
1005
1006    _Example_
1007    \code
1008    wc_Shake shake[1];
1009    byte data[] = { ハッシュ化されるデータ };
1010    word32 len = sizeof(data);
1011
1012    if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
1013       WOLFSSL_MSG("wc_InitShake256 failed");
1014    }
1015    else {
1016        wc_Shake256_Update(shake, data, len);
1017        wc_Shake256_Final(shake, hash, sizeof(hash));
1018    }
1019    \endcode
1020
1021    \sa wc_Shake256Hash
1022    \sa wc_Shake256_Final
1023    \sa wc_InitShake256
1024*/
1025int wc_Shake256_Update(wc_Shake* sha, const byte* data, word32 len);
1026
1027/*!
1028    \ingroup SHA
1029
1030    \brief データのハッシュ化を完了します。結果はhashに格納されます。shake構造体の状態をリセットします。
1031
1032    \return 0 完了に成功した場合に返されます。
1033
1034    \param shake 暗号化に使用するshake構造体へのポインタ
1035    \param hash ハッシュ値を保持するバイト配列。
1036    \param hashLen ハッシュのサイズ（バイト単位）。
1037
1038    _Example_
1039    \code
1040    wc_Shake shake[1];
1041    byte data[] = { ハッシュ化されるデータ };
1042    word32 len = sizeof(data);
1043
1044    if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
1045       WOLFSSL_MSG("wc_InitShake256 failed");
1046    }
1047    else {
1048       wc_Shake256_Update(shake, data, len);
1049       wc_Shake256_Final(shake, hash, sizeof(hash));
1050    }
1051    \endcode
1052
1053    \sa wc_Shake256Hash
1054    \sa wc_Shake256_GetHash
1055    \sa wc_InitShake256
1056*/
1057int wc_Shake256_Final(wc_Shake* shake, byte* hash, word32 hashLen);
1058
1059/*!
1060    \ingroup SHA
1061
1062    \brief 長さlenの提供されたバイト配列を吸収するために呼び出されます。段階的に呼び出すことはできません。
1063
1064    \return 0 データの吸収に成功した場合に返されます。
1065
1066    \param shake 暗号化に使用するshake構造体へのポインタ
1067    \param data 吸収されるデータ
1068    \param len 吸収されるデータの長さ
1069
1070    _Example_
1071    \code
1072    wc_Shake shake[1];
1073    byte data[] = { ハッシュ化されるデータ };
1074    word32 len = sizeof(data);
1075    byte out[2 * WC_SHA3_256_BLOCK_SIZE];
1076    int blocks = 2;
1077
1078    if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
1079       WOLFSSL_MSG("wc_InitShake256 failed");
1080    }
1081    else {
1082       wc_Shake256_Absorb(shake, data, len);
1083       wc_Shake256_SqueezeBlocks(shake, out, blocks);
1084    }
1085    \endcode
1086
1087    \sa wc_Shake256_SqueezeBlocks
1088    \sa wc_InitShake256
1089*/
1090int wc_Shake256_Absorb(wc_Shake* sha, const byte* data, word32 len);
1091
1092/*!
1093    \ingroup SHA
1094
1095    \brief さらに多くのデータブロックを絞り出します。結果はoutに格納されます。段階的に呼び出すことができます。
1096
1097    \return 0 絞り出しに成功した場合に返されます。
1098
1099    \param shake 暗号化に使用するshake構造体へのポインタ
1100    \param hash 出力を保持するバイト配列。
1101    \param blocks 絞り出すブロックの数。各ブロックはWC_SHA3_256_BLOCK_SIZEバイトの長さです。
1102
1103    _Example_
1104    \code
1105    wc_Shake shake[1];
1106    byte data[] = { ハッシュ化されるデータ };
1107    word32 len = sizeof(data);
1108    byte out[2 * WC_SHA3_256_BLOCK_SIZE];
1109    int blocks = 2;
1110
1111    if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
1112       WOLFSSL_MSG("wc_InitShake256 failed");
1113    }
1114    else {
1115       wc_Shake256_Absorb(shake, data, len);
1116       wc_Shake256_SqueezeBlocks(shake, out, blocks);
1117    }
1118    \endcode
1119
1120    \sa wc_Shake256_Absorb
1121    \sa wc_InitShake256
1122*/
1123int wc_Shake256_SqueezeBlocks(wc_Shake* shake, byte* out, word32 blockCnt);
1124
1125/*!
1126    \ingroup SHA
1127
1128    \brief wc_Shake構造体をリセットします。注：これはWOLFSSL_TI_HASHが定義されている場合のみサポートされます。
1129
1130    \return none 戻り値なし。
1131
1132    \param shake 解放されるshake構造体へのポインタ。
1133
1134    _Example_
1135    \code
1136    wc_Shake shake;
1137    byte data[] = { ハッシュ化されるデータ };
1138    word32 len = sizeof(data);
1139
1140    if ((ret = wc_InitShake256(&shake, NULL, INVALID_DEVID)) != 0) {
1141        WOLFSSL_MSG("wc_InitShake256 failed");
1142    }
1143    else {
1144        wc_Shake256_Update(&shake, data, len);
1145        wc_Shake256_Final(&shake, hash, sizeof(hash));
1146        wc_Shake256_Free(&shake);
1147    }
1148    \endcode
1149
1150    \sa wc_InitShake256
1151    \sa wc_Shake256_Update
1152    \sa wc_Shake256_Final
1153*/
1154void wc_Shake256_Free(wc_Shake* shake);
1155
1156/*!
1157    \ingroup SHA
1158
1159    \brief ハッシュデータを取得します。結果はhashに格納されます。shake構造体の状態をリセットしません。
1160
1161    \return 0 ハッシュのコピーに成功した場合に返されます。
1162
1163    \param shake 暗号化に使用するshake構造体へのポインタ
1164    \param hash ハッシュ値を保持するバイト配列。
1165
1166    _Example_
1167    \code
1168    wc_Shake shake[1];
1169    if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
1170       WOLFSSL_MSG("wc_InitShake256 failed");
1171    }
1172    else {
1173       wc_Shake256_Update(shake, data, len);
1174       wc_Shake256_GetHash(shake, hash);
1175    }
1176    \endcode
1177
1178    \sa wc_Shake256Hash
1179    \sa wc_Shake256_Final
1180    \sa wc_InitShake256
1181    \sa wc_Shake256_Copy
1182*/
1183int wc_Shake256_GetHash(wc_Shake* shake, byte* hash);
1184
1185/*!
1186    \ingroup SHA
1187
1188    \brief ハッシュの状態をコピーします。
1189
1190    \return 0 コピーに成功した場合に返されます。
1191
1192    \param src コピーするshake構造体へのポインタ
1193    \param dst  コピー先のshake構造体へのポインタ
1194
1195    _Example_
1196    \code
1197    wc_Shake shake[1];
1198    wc_Shake shake_dup[1];
1199    if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
1200       WOLFSSL_MSG("wc_InitShake256 failed");
1201    }
1202    else {
1203       wc_Shake256_Update(shake, data, len);
1204       wc_Shake256_Copy(shake, shake_dup);
1205    }
1206    \endcode
1207
1208    \sa wc_Shake256Hash
1209    \sa wc_Shake256_Final
1210    \sa wc_InitShake256
1211    \sa wc_Shake256_GetHash
1212*/
1213int wc_Shake256_Copy(wc_Shake* src, wc_Sha3* dst);