luna - wolfssl/doc/dox_comments/header

   1/*!
   2    \ingroup RSA
   3
   4    \brief この関数は、提供されたRsaKey構造体を初期化します。また、ユーザー定義のメモリオーバーライド（XMALLOC、XFREE、XREALLOCを参照）で使用するために、ヒープ識別子も受け取ります。
   5
   6    WC_RSA_BLINDINGが有効になっている場合、キーはwc_RsaSetRNGによってRNGと関連付ける必要があります。
   7
   8    \return 0 暗号化と復号に使用するRSA構造体の初期化に成功した場合に返されます
   9    \return BAD_FUNC_ARGS RSAキーポインタがNULLと評価された場合に返されます
  10
  11    \param key 初期化するRsaKey構造体へのポインタ
  12    \param heap メモリオーバーライドで使用するヒープ識別子へのポインタ。メモリ割り当てのカスタム処理を可能にします。このヒープは、このRSAオブジェクトで使用するメモリを割り当てる際にデフォルトで使用されます
  13
  14    _Example_
  15    \code
  16    RsaKey enc;
  17    int ret;
  18    ret = wc_InitRsaKey(&enc, NULL); // ヒープヒントを使用しない。カスタムメモリなし
  19    if ( ret != 0 ) {
  20    	// RSAキーの初期化エラー
  21    }
  22    \endcode
  23
  24    \sa wc_FreeRsaKey
  25    \sa wc_RsaSetRNG
  26*/
  27int  wc_InitRsaKey(RsaKey* key, void* heap);
  28
  29/*!
  30    \ingroup RSA
  31
  32    \brief この関数は、提供されたRsaKey構造体を初期化します。idとlenは、デバイス上のキーを識別するために使用され、devIdはデバイスを識別します。また、ユーザー定義のメモリオーバーライド（XMALLOC、XFREE、XREALLOCを参照）で使用するために、ヒープ識別子も受け取ります。
  33
  34    WC_RSA_BLINDINGが有効になっている場合、キーはwc_RsaSetRNGによってRNGと関連付ける必要があります。
  35
  36    \return 0 暗号化と復号に使用するRSA構造体の初期化に成功した場合に返されます
  37    \return BAD_FUNC_ARGS RSAキーポインタがNULLと評価された場合に返されます
  38    \return BUFFER_E lenが0未満またはRSA_MAX_ID_LENより大きい場合に返されます。
  39
  40    \param key 初期化するRsaKey構造体へのポインタ
  41    \param id デバイス上のキーの識別子
  42    \param len 識別子の長さ（バイト単位）
  43    \param heap メモリオーバーライドで使用するヒープ識別子へのポインタ。メモリ割り当てのカスタム処理を可能にします。このヒープは、このRSAオブジェクトで使用するメモリを割り当てる際にデフォルトで使用されます
  44    \param devId 暗号コールバックまたは非同期ハードウェアで使用するID。使用しない場合はINVALID_DEVID（-2）に設定
  45
  46    _Example_
  47    \code
  48    RsaKey enc;
  49    unsigned char* id = (unsigned char*)"RSA2048";
  50    int len = 7;
  51    int devId = 1;
  52    int ret;
  53    ret = wc_CryptoDev_RegisterDevice(devId, wc_Pkcs11_CryptoDevCb,
  54                                      &token);
  55    if ( ret != 0) {
  56        // コールバックとトークンをデバイスIDに関連付けるエラー
  57    }
  58    ret = wc_InitRsaKey_Id(&enc, id, len, NULL, devId); // ヒープヒントを使用しない
  59    if ( ret != 0 ) {
  60        // RSAキーの初期化エラー
  61    }
  62    \endcode
  63
  64    \sa wc_InitRsaKey
  65    \sa wc_FreeRsaKey
  66    \sa wc_RsaSetRNG
  67*/
  68int  wc_InitRsaKey_Id(RsaKey* key, unsigned char* id, int len,
  69        void* heap, int devId);
  70
  71/*!
  72    \ingroup RSA
  73
  74    \brief この関数は、RNGをキーに関連付けます。WC_RSA_BLINDINGが有効になっている場合に必要です。
  75
  76    \return 0 成功時に返されます
  77    \return BAD_FUNC_ARGS RSAキー、rngポインタがNULLと評価された場合に返されます
  78
  79    \param key 関連付けるRsaKey構造体へのポインタ
  80    \param rng 関連付けるWC_RNG構造体へのポインタ
  81
  82    _Example_
  83    \code
  84    ret = wc_InitRsaKey(&key, NULL);
  85    if (ret == 0) {
  86        ret = wc_InitRng(&rng);
  87    } else return -1;
  88    if (ret == 0) {
  89        ret = wc_RsaSetRNG(&key, &rng);
  90    \endcode
  91
  92    \sa wc_InitRsaKey
  93    \sa wc_RsaSetRNG
  94*/
  95int wc_RsaSetRNG(RsaKey* key, WC_RNG* rng);
  96
  97/*!
  98    \ingroup RSA
  99
 100    \brief この関数は、mp_clearを使用して提供されたRsaKey構造体を解放します。
 101
 102    \return 0 キーの解放に成功した場合に返されます
 103
 104    \param key 解放するRsaKey構造体へのポインタ
 105
 106    _Example_
 107    \code
 108    RsaKey enc;
 109    wc_InitRsaKey(&enc, NULL); // ヒープヒントを使用しない。カスタムメモリなし
 110    ... キーを設定し、暗号化を実行
 111
 112    wc_FreeRsaKey(&enc);
 113    \endcode
 114
 115    \sa wc_InitRsaKey
 116*/
 117int  wc_FreeRsaKey(RsaKey* key);
 118
 119/*!
 120    \ingroup RSA
 121
 122    \brief パディングなしでRSA操作を直接実行する関数。入力サイズはキーサイズと一致する必要があります。通常、これはRSA入力に既にパディングが行われている場合に使用されます。
 123
 124    \return size 暗号化に成功した場合、暗号化されたバッファのサイズが返されます
 125    \return RSA_BUFFER_E RSAバッファエラー、出力が小さすぎるか入力が大きすぎます
 126
 127    \param in 操作を行うバッファ
 128    \param inLen 入力バッファの長さ
 129    \param out 結果を保持するバッファ
 130    \param outSz 結果バッファのサイズに設定されます。出力バッファの長さとして渡す必要があります。ポインタ「out」がnullの場合、outSzは必要な予想バッファサイズに設定され、LENGTH_ONLY_Eが返されます。
 131    \param key 暗号化/復号に使用する初期化されたRSAキー
 132    \param type 秘密鍵または公開鍵を使用する場合（RSA_PUBLIC_ENCRYPT、RSA_PUBLIC_DECRYPT、RSA_PRIVATE_ENCRYPT、RSA_PRIVATE_DECRYPT）
 133    \param rng 初期化されたWC_RNG構造体
 134
 135    _Example_
 136    \code
 137    int ret;
 138    WC_RNG rng;
 139    RsaKey key;
 140    byte  in[256];
 141    byte out[256];
 142    word32 outSz = (word32)sizeof(out);
 143    …
 144
 145    ret = wc_RsaDirect(in, (word32)sizeof(in), out, &outSz, &key,
 146        RSA_PRIVATE_ENCRYPT, &rng);
 147    if (ret < 0) {
 148	    // エラーを処理
 149    }
 150    \endcode
 151
 152    \sa wc_RsaPublicEncrypt
 153    \sa wc_RsaPrivateDecrypt
 154*/
 155int wc_RsaDirect(const byte* in, word32 inLen, byte* out, word32* outSz,
 156        RsaKey* key, int type, WC_RNG* rng);
 157
 158/*!
 159    \ingroup RSA
 160
 161    \brief この関数は、inからメッセージを暗号化し、結果をoutに格納します。初期化された公開鍵と乱数ジェネレータが必要です。副作用として、この関数はoutに書き込まれたバイト数をoutLenで返します。
 162
 163    \return Success 入力メッセージの暗号化に成功した場合、成功時に書き込まれたバイト数を返し、失敗の場合はゼロ未満を返します。
 164    \return BAD_FUNC_ARG いずれかの入力パラメータが無効な場合に返されます
 165    \return RSA_BUFFER_E 出力バッファが暗号文を格納するには小さすぎる場合に返されます
 166    \return RNG_FAILURE_E 提供されたRNG構造体を使用してランダムブロックを生成する際にエラーがある場合に返されます
 167    \return MP_INIT_E メッセージの暗号化中に使用される数学ライブラリにエラーがある場合に返される可能性があります
 168    \return MP_READ_E メッセージの暗号化中に使用される数学ライブラリにエラーがある場合に返される可能性があります
 169    \return MP_CMP_E メッセージの暗号化中に使用される数学ライブラリにエラーがある場合に返される可能性があります
 170    \return MP_INVMOD_E メッセージの暗号化中に使用される数学ライブラリにエラーがある場合に返される可能性があります
 171    \return MP_EXPTMOD_E メッセージの暗号化中に使用される数学ライブラリにエラーがある場合に返される可能性があります
 172    \return MP_MOD_E メッセージの暗号化中に使用される数学ライブラリにエラーがある場合に返される可能性があります
 173    \return MP_MUL_E メッセージの暗号化中に使用される数学ライブラリにエラーがある場合に返される可能性があります
 174    \return MP_ADD_E メッセージの暗号化中に使用される数学ライブラリにエラーがある場合に返される可能性があります
 175    \return MP_MULMOD_E メッセージの暗号化中に使用される数学ライブラリにエラーがある場合に返される可能性があります
 176    \return MP_TO_E メッセージの暗号化中に使用される数学ライブラリにエラーがある場合に返される可能性があります
 177    \return MP_MEM メッセージの暗号化中に使用される数学ライブラリにエラーがある場合に返される可能性があります
 178    \return MP_ZERO_E メッセージの暗号化中に使用される数学ライブラリにエラーがある場合に返される可能性があります
 179
 180    \param in 暗号化する入力メッセージを含むバッファへのポインタ
 181    \param inLen 暗号化するメッセージの長さ
 182    \param out 出力暗号文を格納するバッファへのポインタ
 183    \param outLen 出力バッファの長さ
 184    \param key 暗号化に使用する公開鍵を含むRsaKey構造体へのポインタ
 185    \param rng ランダムブロックパディングを生成するRNG構造体
 186
 187    _Example_
 188    \code
 189    RsaKey pub;
 190    int ret = 0;
 191    byte n[] = { // 受信した公開鍵のn成分で初期化 };
 192    byte e[] = { // 受信した公開鍵のe成分で初期化 };
 193    byte msg[] = { // 暗号化するメッセージの平文で初期化 };
 194    byte cipher[256]; // 256バイトは2048ビットRSA暗号文を格納するのに十分な大きさ
 195
 196    wc_InitRsaKey(&pub, NULL); // ヒープヒントを使用しない。カスタムメモリなし
 197    wc_RsaPublicKeyDecodeRaw(n, sizeof(n), e, sizeof(e), &pub);
 198    // 受信した公開鍵パラメータで初期化
 199    ret = wc_RsaPublicEncrypt(msg, sizeof(msg), out, sizeof(out), &pub, &rng);
 200    if ( ret != 0 ) {
 201    	// メッセージの暗号化エラー
 202    }
 203    \endcode
 204
 205    \sa wc_RsaPrivateDecrypt
 206*/
 207int  wc_RsaPublicEncrypt(const byte* in, word32 inLen, byte* out,
 208                                 word32 outLen, RsaKey* key, WC_RNG* rng);
 209
 210/*!
 211    \ingroup RSA
 212
 213    \brief この関数は、復号のためにwc_RsaPrivateDecrypt関数によって使用されます。
 214
 215    \return Success 復号されたデータの長さ。
 216    \return RSA_PAD_E RsaUnPadエラー、フォーマットが不正
 217
 218    \param in 復号されるバイト配列。
 219    \param inLen inの長さ。
 220    \param out 復号されたデータを格納するバイト配列。
 221    \param key 復号に使用するキー。
 222
 223    _Example_
 224    \code
 225    なし
 226    \endcode
 227
 228    \sa wc_RsaPrivateDecrypt
 229*/
 230int  wc_RsaPrivateDecryptInline(byte* in, word32 inLen, byte** out,
 231                                        RsaKey* key);
 232
 233/*!
 234    \ingroup RSA
 235
 236    \brief この関数は、プライベートRSA復号を提供します。
 237
 238    \return Success 復号されたデータの長さ。
 239    \return MEMORY_E -125、メモリ不足エラー
 240    \return BAD_FUNC_ARG -173、不正な関数引数が提供されました
 241
 242    \param in 復号されるバイト配列。
 243    \param inLen inの長さ。
 244    \param out 復号されたデータを格納するバイト配列。
 245    \param outLen outの長さ。
 246    \param key 復号に使用するキー。
 247
 248    _Example_
 249    \code
 250    ret = wc_RsaPublicEncrypt(in, inLen, out, sizeof(out), &key, &rng);
 251    if (ret < 0) {
 252        return -1;
 253    }
 254    ret = wc_RsaPrivateDecrypt(out, ret, plain, sizeof(plain), &key);
 255    if (ret < 0) {
 256        return -1;
 257    }
 258    \endcode
 259
 260    \sa RsaUnPad
 261    \sa wc_RsaFunction
 262    \sa wc_RsaPrivateDecryptInline
 263*/
 264int  wc_RsaPrivateDecrypt(const byte* in, word32 inLen, byte* out,
 265                                  word32 outLen, RsaKey* key);
 266
 267/*!
 268    \ingroup RSA
 269
 270    \brief 秘密鍵で提供された配列に署名します。
 271
 272    \return RSA_BUFFER_E: -131、RSAバッファエラー、出力が小さすぎるか入力が大きすぎます
 273
 274    \param in 暗号化されるバイト配列。
 275    \param inLen inの長さ。
 276    \param out 暗号化されたデータを格納するバイト配列。
 277    \param outLen outの長さ。
 278    \param key 暗号化に使用するキー。
 279    \param RNG 乱数の目的で使用するRNG構造体。
 280
 281    _Example_
 282    \code
 283    ret = wc_RsaSSL_Sign(in, inLen, out, sizeof(out), &key, &rng);
 284    if (ret < 0) {
 285        return -1;
 286    }
 287    memset(plain, 0, sizeof(plain));
 288    ret = wc_RsaSSL_Verify(out, ret, plain, sizeof(plain), &key);
 289    if (ret < 0) {
 290        return -1;
 291    }
 292    if (ret != inLen) {
 293        return -1;
 294    }
 295    if (XMEMCMP(in, plain, ret) != 0) {
 296        return -1;
 297    }
 298    \endcode
 299
 300    \sa wc_RsaPad
 301*/
 302int  wc_RsaSSL_Sign(const byte* in, word32 inLen, byte* out,
 303                            word32 outLen, RsaKey* key, WC_RNG* rng);
 304
 305/*!
 306    \ingroup RSA
 307
 308    \brief メッセージがRSAキーによって署名されたことを検証するために使用されます。出力は入力と同じバイト配列を使用します。
 309
 310    \return `>0` ダイジェストの長さ。
 311    \return `<0` エラーが発生しました。
 312
 313    \param in 復号されるバイト配列。
 314    \param inLen 入力バッファの長さ。
 315    \param out 復号された情報へのポインタへのポインタ。
 316    \param key 使用するRsaKey。
 317
 318    _Example_
 319    \code
 320    RsaKey key;
 321    WC_RNG rng;
 322    int ret = 0;
 323    long e = 65537; // 指数に使用する標準値
 324    wc_InitRsaKey(&key, NULL); // ヒープヒントを使用しない。カスタムメモリなし
 325    wc_InitRng(&rng);
 326    wc_MakeRsaKey(&key, 2048, e, &rng);
 327
 328    byte in[] = { // RSA暗号化情報で初期化 }
 329    byte* out;
 330    if(wc_RsaSSL_VerifyInline(in, sizeof(in), &out, &key) < 0)
 331    {
 332        // エラーを処理
 333    }
 334    \endcode
 335
 336    \sa wc_RsaSSL_Verify
 337    \sa wc_RsaSSL_Sign
 338*/
 339int  wc_RsaSSL_VerifyInline(byte* in, word32 inLen, byte** out,
 340                                    RsaKey* key);
 341
 342/*!
 343    \ingroup RSA
 344
 345    \brief メッセージがキーによって署名されたことを検証するために使用されます。
 346
 347    \return Success エラーがない場合のダイジェストの長さ。
 348    \return MEMORY_E メモリ例外。
 349
 350    \param in 復号されるバイト配列。
 351    \param inLen inの長さ。
 352    \param out 復号されたデータを格納するバイト配列。
 353    \param outLen outの長さ。
 354    \param key 検証に使用するキー。
 355
 356    _Example_
 357    \code
 358    ret = wc_RsaSSL_Sign(in, inLen, out, sizeof(out), &key, &rng);
 359    if (ret < 0) {
 360        return -1;
 361    }
 362    memset(plain, 0, sizeof(plain));
 363    ret = wc_RsaSSL_Verify(out, ret, plain, sizeof(plain), &key);
 364    if (ret < 0) {
 365        return -1;
 366    }
 367    if (ret != inLen) {
 368        return -1;
 369    }
 370    if (XMEMCMP(in, plain, ret) != 0) {
 371        return -1;
 372    }
 373    \endcode
 374
 375    \sa wc_RsaSSL_Sign
 376*/
 377int  wc_RsaSSL_Verify(const byte* in, word32 inLen, byte* out,
 378                              word32 outLen, RsaKey* key);
 379
 380/*!
 381    \ingroup RSA
 382
 383    \brief 秘密鍵で提供された配列に署名します。
 384
 385    \return RSA_BUFFER_E: -131、RSAバッファエラー、出力が小さすぎるか入力が大きすぎます
 386
 387    \param in 暗号化されるバイト配列。
 388    \param inLen inの長さ。
 389    \param out 暗号化されたデータを格納するバイト配列。
 390    \param outLen outの長さ。
 391    \param hash メッセージに含まれるハッシュタイプ
 392    \param mgf マスク生成関数識別子
 393    \param key 検証に使用するキー。
 394
 395    _Example_
 396    \code
 397    ret = wc_InitRsaKey(&key, NULL);
 398    if (ret == 0) {
 399        ret = wc_InitRng(&rng);
 400    } else return -1;
 401    if (ret == 0) {
 402        ret = wc_RsaSetRNG(&key, &rng);
 403    } else return -1;
 404    if (ret == 0) {
 405            ret = wc_MakeRsaKey(&key, 2048, WC_RSA_EXPONENT, &rng);
 406    } else return -1;
 407
 408    ret = wc_RsaPSS_Sign((byte*)szMessage, (word32)XSTRLEN(szMessage)+1,
 409            pSignature, sizeof(pSignature),
 410            WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key, &rng);
 411    if (ret > 0 ){
 412        sz = ret;
 413    } else return -1;
 414
 415    ret = wc_RsaPSS_Verify(pSignature, sz, pt, outLen,
 416            WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key);
 417    if (ret <= 0)return -1;
 418
 419    wc_FreeRsaKey(&key);
 420    wc_FreeRng(&rng);
 421    \endcode
 422
 423    \sa wc_RsaPSS_Verify
 424    \sa wc_RsaSetRNG
 425*/
 426int  wc_RsaPSS_Sign(const byte* in, word32 inLen, byte* out,
 427                                word32 outLen, enum wc_HashType hash, int mgf,
 428                                RsaKey* key, WC_RNG* rng);
 429
 430/*!
 431    \ingroup RSA
 432
 433    \brief メッセージがキーによって署名されたことを検証するために入力署名を復号します。WC_RSA_BLINDINGが有効になっている場合、キーはwc_RsaSetRNGによってRNGと関連付ける必要があります。
 434
 435    \return Success エラーがない場合のテキストの長さ。
 436    \return MEMORY_E メモリ例外。
 437    \return MP_EXPTMOD_E - fastmathを使用していて、FP_MAX_BITSがキーサイズの少なくとも2倍に設定されていない場合（例：4096ビットキーを使用する場合、FP_MAX_BITSを8192以上の値に設定）
 438
 439    \param in 復号されるバイト配列。
 440    \param inLen inの長さ。
 441    \param out 復号されたデータを格納するバイト配列。
 442    \param outLen outの長さ。
 443    \param hash メッセージに含まれるハッシュタイプ
 444    \param mgf マスク生成関数識別子
 445    \param key 検証に使用するキー。
 446
 447    _Example_
 448    \code
 449    ret = wc_InitRsaKey(&key, NULL);
 450    if (ret == 0) {
 451        ret = wc_InitRng(&rng);
 452    } else return -1;
 453    if (ret == 0) {
 454        ret = wc_RsaSetRNG(&key, &rng);
 455    } else return -1;
 456    if (ret == 0) {
 457            ret = wc_MakeRsaKey(&key, 2048, WC_RSA_EXPONENT, &rng);
 458    } else return -1;
 459    ret = wc_RsaPSS_Sign((byte*)szMessage, (word32)XSTRLEN(szMessage)+1,
 460            pSignature, sizeof(pSignature),
 461            WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key, &rng);
 462    if (ret > 0 ){
 463        sz = ret;
 464    } else return -1;
 465
 466    ret = wc_RsaPSS_Verify(pSignature, sz, pt, outLen,
 467            WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key);
 468    if (ret <= 0)return -1;
 469
 470    wc_FreeRsaKey(&key);
 471    wc_FreeRng(&rng);
 472    \endcode
 473
 474    \sa wc_RsaPSS_Sign
 475    \sa wc_RsaPSS_VerifyInline
 476    \sa wc_RsaPSS_CheckPadding
 477    \sa wc_RsaSetRNG
 478*/
 479int  wc_RsaPSS_Verify(const byte* in, word32 inLen, byte* out,
 480                                  word32 outLen, enum wc_HashType hash, int mgf,
 481                                  RsaKey* key);
 482
 483/*!
 484    \ingroup RSA
 485
 486    \brief メッセージがRSAキーによって署名されたことを検証するために入力署名を復号します。出力は入力と同じバイト配列を使用します。WC_RSA_BLINDINGが有効になっている場合、キーはwc_RsaSetRNGによってRNGと関連付ける必要があります。
 487
 488    \return >0 テキストの長さ。
 489    \return <0 エラーが発生しました。
 490
 491    \param in 復号されるバイト配列。
 492    \param inLen 入力バッファの長さ。
 493    \param out PSSデータを含むアドレスへのポインタ。
 494    \param hash メッセージに含まれるハッシュタイプ
 495    \param mgf マスク生成関数識別子
 496    \param key 使用するRsaKey。
 497
 498    _Example_
 499    \code
 500    ret = wc_InitRsaKey(&key, NULL);
 501    if (ret == 0) {
 502        ret = wc_InitRng(&rng);
 503    } else return -1;
 504    if (ret == 0) {
 505        ret = wc_RsaSetRNG(&key, &rng);
 506    } else return -1;
 507    if (ret == 0) {
 508            ret = wc_MakeRsaKey(&key, 2048, WC_RSA_EXPONENT, &rng);
 509    } else return -1;
 510    ret = wc_RsaPSS_Sign(digest, digestSz, pSignature, pSignatureSz,
 511            WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key, &rng);
 512    if (ret > 0 ){
 513        sz = ret;
 514    } else return -1;
 515
 516    ret = wc_RsaPSS_VerifyInline(pSignature, sz, pt,
 517            WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key);
 518    if (ret <= 0)return -1;
 519
 520    wc_FreeRsaKey(&key);
 521    wc_FreeRng(&rng);
 522    \endcode
 523
 524    \sa wc_RsaPSS_Verify
 525    \sa wc_RsaPSS_Sign
 526    \sa wc_RsaPSS_VerifyCheck
 527    \sa wc_RsaPSS_VerifyCheck_ex
 528    \sa wc_RsaPSS_VerifyCheckInline
 529    \sa wc_RsaPSS_VerifyCheckInline_ex
 530    \sa wc_RsaPSS_CheckPadding
 531    \sa wc_RsaPSS_CheckPadding_ex
 532    \sa wc_RsaSetRNG
 533*/
 534
 535
 536int  wc_RsaPSS_VerifyInline(byte* in, word32 inLen, byte** out,
 537                                        enum wc_HashType hash, int mgf,
 538                                        RsaKey* key);
 539/*!
 540    \ingroup RSA
 541
 542    \brief RSA-PSSで署名されたメッセージを検証します。ソルトの長さはハッシュの長さと等しくなります。WC_RSA_BLINDINGが有効になっている場合、キーはwc_RsaSetRNGによってRNGと関連付ける必要があります。
 543
 544    \return the length of the PSS data 成功時はPSSデータの長さ、失敗を示す負の値。
 545    \return MEMORY_E メモリ例外。
 546
 547    \param in 復号されるバイト配列。
 548    \param inLen inの長さ。
 549    \param out PSSデータを含むアドレスへのポインタ。
 550    \param outLen outの長さ。
 551    \param digest 検証されるデータのハッシュ。
 552    \param digestLen ハッシュの長さ。
 553    \param hash ハッシュアルゴリズム。
 554    \param mgf マスク生成関数。
 555    \param key 公開RSAキー。
 556
 557    _Example_
 558    \code
 559    ret = wc_InitRsaKey(&key, NULL);
 560    if (ret == 0) {
 561        ret = wc_InitRng(&rng);
 562    } else return -1;
 563    if (ret == 0) {
 564        ret = wc_RsaSetRNG(&key, &rng);
 565    } else return -1;
 566    if (ret == 0) {
 567            ret = wc_MakeRsaKey(&key, 2048, WC_RSA_EXPONENT, &rng);
 568    } else return -1;
 569
 570    if (ret == 0) {
 571        digestSz = wc_HashGetDigestSize(WC_HASH_TYPE_SHA256);
 572        ret = wc_Hash(WC_HASH_TYPE_SHA256, message, sz, digest, digestSz);
 573    } else return -1;
 574
 575    if (ret == 0) {
 576        ret = wc_RsaPSS_Sign(digest, digestSz, pSignature, pSignatureSz,
 577                WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key, &rng);
 578        if (ret > 0 ){
 579            sz = ret;
 580        } else return -1;
 581    } else return -1;
 582    if (ret == 0) {
 583        ret = wc_RsaPSS_VerifyCheck(pSignature, sz, pt, outLen,
 584                digest, digestSz, WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key);
 585            if (ret <= 0) return -1;
 586    } else return -1;
 587
 588    wc_FreeRsaKey(&key);
 589    wc_FreeRng(&rng);
 590    \endcode
 591
 592    \sa wc_RsaPSS_Sign
 593    \sa wc_RsaPSS_Verify
 594    \sa wc_RsaPSS_VerifyCheck_ex
 595    \sa wc_RsaPSS_VerifyCheckInline
 596    \sa wc_RsaPSS_VerifyCheckInline_ex
 597    \sa wc_RsaPSS_CheckPadding
 598    \sa wc_RsaPSS_CheckPadding_ex
 599    \sa wc_RsaSetRNG
 600*/
 601
 602int  wc_RsaPSS_VerifyCheck(const byte* in, word32 inLen,
 603                               byte* out, word32 outLen,
 604                               const byte* digest, word32 digestLen,
 605                               enum wc_HashType hash, int mgf,
 606                               RsaKey* key);
 607/*!
 608    \ingroup RSA
 609
 610    \brief RSA-PSSで署名されたメッセージを検証します。WC_RSA_BLINDINGが有効になっている場合、キーはwc_RsaSetRNGによってRNGと関連付ける必要があります。
 611
 612    \return the length of the PSS data 成功時はPSSデータの長さ、失敗を示す負の値。
 613    \return MEMORY_E メモリ例外。
 614
 615    \param in 復号されるバイト配列。
 616    \param inLen inの長さ。
 617    \param out PSSデータを含むアドレスへのポインタ。
 618    \param outLen outの長さ。
 619    \param digest 検証されるデータのハッシュ。
 620    \param digestLen ハッシュの長さ。
 621    \param hash ハッシュアルゴリズム。
 622    \param mgf マスク生成関数。
 623    \param saltLen 使用されるソルトの長さ。RSA_PSS_SALT_LEN_DEFAULT（-1）は、ソルトの長さがハッシュの長さと同じであることを示します。RSA_PSS_SALT_LEN_DISCOVERは、ソルトの長さがデータから決定されることを示します。
 624
 625    \param key 公開RSAキー。
 626
 627    _Example_
 628    \code
 629    ret = wc_InitRsaKey(&key, NULL);
 630    if (ret == 0) {
 631        ret = wc_InitRng(&rng);
 632    } else return -1;
 633    if (ret == 0) {
 634        ret = wc_RsaSetRNG(&key, &rng);
 635    } else return -1;
 636    if (ret == 0) {
 637            ret = wc_MakeRsaKey(&key, 2048, WC_RSA_EXPONENT, &rng);
 638    } else return -1;
 639
 640    if (ret == 0) {
 641        digestSz = wc_HashGetDigestSize(WC_HASH_TYPE_SHA256);
 642        ret = wc_Hash(WC_HASH_TYPE_SHA256, message, sz, digest, digestSz);
 643    } else return -1;
 644
 645    if (ret == 0) {
 646        ret = wc_RsaPSS_Sign(digest, digestSz, pSignature, pSignatureSz,
 647                WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key, &rng);
 648        if (ret > 0 ){
 649            sz = ret;
 650        } else return -1;
 651    } else return -1;
 652    if (ret == 0) {
 653        ret = wc_RsaPSS_VerifyCheck_ex(pSignature, sz, pt, outLen,
 654                digest, digestSz, WC_HASH_TYPE_SHA256, WC_MGF1SHA256, saltLen, &key);
 655            if (ret <= 0) return -1;
 656    } else return -1;
 657
 658    wc_FreeRsaKey(&key);
 659    wc_FreeRng(&rng);
 660    \endcode
 661
 662    \sa wc_RsaPSS_Sign
 663    \sa wc_RsaPSS_Verify
 664    \sa wc_RsaPSS_VerifyCheck
 665    \sa wc_RsaPSS_VerifyCheckInline
 666    \sa wc_RsaPSS_VerifyCheckInline_ex
 667    \sa wc_RsaPSS_CheckPadding
 668    \sa wc_RsaPSS_CheckPadding_ex
 669    \sa wc_RsaSetRNG
 670*/
 671int  wc_RsaPSS_VerifyCheck_ex(byte* in, word32 inLen,
 672                               byte* out, word32 outLen,
 673                               const byte* digest, word32 digestLen,
 674                               enum wc_HashType hash, int mgf, int saltLen,
 675                               RsaKey* key);
 676
 677/*!
 678    \ingroup RSA
 679
 680    \brief RSA-PSSで署名されたメッセージを検証します。入力バッファは出力バッファとして再利用されます。ソルトの長さはハッシュの長さと等しくなります。
 681
 682    WC_RSA_BLINDINGが有効になっている場合、キーはwc_RsaSetRNGによってRNGと関連付ける必要があります。
 683
 684    \return the length of the PSS data 成功時はPSSデータの長さ、失敗を示す負の値。
 685
 686    \param in 復号されるバイト配列。
 687    \param inLen inの長さ。
 688    \param out 復号されたデータを格納するバイト配列。
 689    \param digest 検証されるデータのハッシュ。
 690    \param digestLen ハッシュの長さ。
 691    \param hash メッセージに含まれるハッシュタイプ
 692    \param mgf マスク生成関数識別子
 693    \param key 検証に使用するキー。
 694
 695    _Example_
 696    \code
 697    ret = wc_InitRsaKey(&key, NULL);
 698    if (ret == 0) {
 699        ret = wc_InitRng(&rng);
 700    } else return -1;
 701    if (ret == 0) {
 702        ret = wc_RsaSetRNG(&key, &rng);
 703    } else return -1;
 704    if (ret == 0) {
 705            ret = wc_MakeRsaKey(&key, 2048, WC_RSA_EXPONENT, &rng);
 706    } else return -1;
 707
 708    if (ret == 0) {
 709        digestSz = wc_HashGetDigestSize(WC_HASH_TYPE_SHA256);
 710        ret = wc_Hash(WC_HASH_TYPE_SHA256, message, sz, digest, digestSz);
 711    } else return -1;
 712
 713    if (ret == 0) {
 714        ret = wc_RsaPSS_Sign(digest, digestSz, pSignature, pSignatureSz,
 715                WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key, &rng);
 716        if (ret > 0 ){
 717            sz = ret;
 718        } else return -1;
 719    } else return -1;
 720    if (ret == 0) {
 721        ret = wc_RsaPSS_VerifyCheckInline(pSignature, sz, pt,
 722                digest, digestSz, WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key);
 723            if (ret <= 0) return -1;
 724    } else return -1;
 725
 726    wc_FreeRsaKey(&key);
 727    wc_FreeRng(&rng);
 728    \endcode
 729
 730    \sa wc_RsaPSS_Sign
 731    \sa wc_RsaPSS_Verify
 732    \sa wc_RsaPSS_VerifyCheck
 733    \sa wc_RsaPSS_VerifyCheck_ex
 734    \sa wc_RsaPSS_VerifyCheckInline_ex
 735    \sa wc_RsaPSS_CheckPadding
 736    \sa wc_RsaPSS_CheckPadding_ex
 737    \sa wc_RsaSetRNG
 738*/
 739int  wc_RsaPSS_VerifyCheckInline(byte* in, word32 inLen, byte** out,
 740                               const byte* digest, word32 digentLen,
 741                               enum wc_HashType hash, int mgf,
 742                               RsaKey* key);
 743/*!
 744    \ingroup RSA
 745
 746    \brief RSA-PSSで署名されたメッセージを検証します。入力バッファは出力バッファとして再利用されます。WC_RSA_BLINDINGが有効になっている場合、キーはwc_RsaSetRNGによってRNGと関連付ける必要があります。
 747
 748    \return the length of the PSS data 成功時はPSSデータの長さ、失敗を示す負の値。
 749
 750    \param in 復号されるバイト配列。
 751    \param inLen inの長さ。
 752    \param out 復号されたデータを格納するバイト配列。
 753    \param digest 検証されるデータのハッシュ。
 754    \param digestLen ハッシュの長さ。
 755    \param hash メッセージに含まれるハッシュタイプ
 756    \param mgf マスク生成関数識別子
 757    \param saltLen 使用されるソルトの長さ。RSA_PSS_SALT_LEN_DEFAULT（-1）は、ソルトの長さがハッシュの長さと同じであることを示します。RSA_PSS_SALT_LEN_DISCOVERは、ソルトの長さがデータから決定されることを示します。
 758    \param key 検証に使用するキー。
 759
 760    _Example_
 761    \code
 762    ret = wc_InitRsaKey(&key, NULL);
 763    if (ret == 0) {
 764        ret = wc_InitRng(&rng);
 765    } else return -1;
 766    if (ret == 0) {
 767        ret = wc_RsaSetRNG(&key, &rng);
 768    } else return -1;
 769    if (ret == 0) {
 770            ret = wc_MakeRsaKey(&key, 2048, WC_RSA_EXPONENT, &rng);
 771    } else return -1;
 772
 773    if (ret == 0) {
 774        digestSz = wc_HashGetDigestSize(WC_HASH_TYPE_SHA256);
 775        ret = wc_Hash(WC_HASH_TYPE_SHA256, message, sz, digest, digestSz);
 776    } else return -1;
 777
 778    if (ret == 0) {
 779        ret = wc_RsaPSS_Sign(digest, digestSz, pSignature, pSignatureSz,
 780                WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key, &rng);
 781        if (ret > 0 ){
 782            sz = ret;
 783        } else return -1;
 784    } else return -1;
 785    if (ret == 0) {
 786        ret = wc_RsaPSS_VerifyCheckInline_ex(pSignature, sz, pt,
 787                digest, digestSz, WC_HASH_TYPE_SHA256, WC_MGF1SHA256, saltLen, &key);
 788            if (ret <= 0) return -1;
 789    } else return -1;
 790
 791    wc_FreeRsaKey(&key);
 792    wc_FreeRng(&rng);
 793    \endcode
 794
 795    \sa wc_RsaPSS_Sign
 796    \sa wc_RsaPSS_Verify
 797    \sa wc_RsaPSS_VerifyCheck
 798    \sa wc_RsaPSS_VerifyCheck_ex
 799    \sa wc_RsaPSS_VerifyCheckInline
 800    \sa wc_RsaPSS_CheckPadding
 801    \sa wc_RsaPSS_CheckPadding_ex
 802    \sa wc_RsaSetRNG
 803*/
 804int  wc_RsaPSS_VerifyCheckInline_ex(byte* in, word32 inLen, byte** out,
 805                               const byte* digest, word32 digentLen,
 806                               enum wc_HashType hash, int mgf, int saltLen,
 807                               RsaKey* key);
 808
 809/*!
 810    \ingroup RSA
 811
 812    \brief 署名が一致することを確認するためにPSSデータをチェックします。ソルトの長さはハッシュの長さと等しくなります。WC_RSA_BLINDINGが有効になっている場合、キーはwc_RsaSetRNGによってRNGと関連付ける必要があります。
 813
 814    \return BAD_PADDING_E PSSデータが無効な場合、BAD_FUNC_ARG inまたはsigにNULLが渡された場合、またはinSzがハッシュアルゴリズムの長さと同じでない場合、成功時は0。
 815    \return MEMORY_E メモリ例外。
 816
 817    \param in 検証されるデータのハッシュ。
 818    \param inSz ハッシュの長さ。
 819    \param sig PSSデータを保持するバッファ。
 820    \param sigSz PSSデータのサイズ。
 821    \param hashType ハッシュアルゴリズム。
 822
 823    _Example_
 824    \code
 825    ret = wc_InitRsaKey(&key, NULL);
 826    if (ret == 0) {
 827        ret = wc_InitRng(&rng);
 828    } else return -1;
 829    if (ret == 0) {
 830        ret = wc_RsaSetRNG(&key, &rng);
 831    } else return -1;
 832    if (ret == 0) {
 833            ret = wc_MakeRsaKey(&key, 2048, WC_RSA_EXPONENT, &rng);
 834    } else return -1;
 835    if (ret == 0) {
 836        digestSz = wc_HashGetDigestSize(WC_HASH_TYPE_SHA256);
 837        ret = wc_Hash(WC_HASH_TYPE_SHA256, message, sz, digest, digestSz);
 838    } else return -1;
 839    ret = wc_RsaPSS_Sign(digest, digestSz, pSignature, sizeof(pSignature),
 840            WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key, &rng);
 841    if (ret > 0 ){
 842        sz = ret;
 843    } else return -1;
 844
 845    verify = wc_RsaPSS_Verify(pSignature, sz, out, outLen,
 846            WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key);
 847    if (verify <= 0)return -1;
 848
 849    ret = wc_RsaPSS_CheckPadding(digest, digestSz, out, verify, hash);
 850
 851    wc_FreeRsaKey(&key);
 852    wc_FreeRng(&rng);
 853    \endcode
 854
 855    \sa wc_RsaPSS_Sign
 856    \sa wc_RsaPSS_Verify
 857    \sa wc_RsaPSS_VerifyInline
 858    \sa wc_RsaPSS_VerifyCheck
 859    \sa wc_RsaPSS_VerifyCheck_ex
 860    \sa wc_RsaPSS_VerifyCheckInline
 861    \sa wc_RsaPSS_VerifyCheckInline_ex
 862    \sa wc_RsaPSS_CheckPadding_ex
 863    \sa wc_RsaSetRNG
 864*/
 865int  wc_RsaPSS_CheckPadding(const byte* in, word32 inLen, const byte* sig,
 866                                        word32 sigSz,
 867                                        enum wc_HashType hashType);
 868/*!
 869    \ingroup RSA
 870
 871    \brief 署名が一致することを確認するためにPSSデータをチェックします。ソルトの長さはハッシュの長さと等しくなります。
 872
 873    \return BAD_PADDING_E PSSデータが無効な場合、BAD_FUNC_ARG inまたはsigにNULLが渡された場合、またはinSzがハッシュアルゴリズムの長さと同じでない場合、成功時は0。
 874    \return MEMORY_E メモリ例外。
 875
 876    \param in        検証されるデータのハッシュ。
 877    \param inSz      ハッシュの長さ。
 878    \param sig       PSSデータを保持するバッファ。
 879    \param sigSz     PSSデータのサイズ。
 880    \param hashType  ハッシュアルゴリズム。
 881    \param saltLen   使用されるソルトの長さ。RSA_PSS_SALT_LEN_DEFAULT（-1）は、ソルトの長さがハッシュの長さと同じであることを示します。RSA_PSS_SALT_LEN_DISCOVERは、ソルトの長さがデータから決定されることを示します。
 882    \param bits      FIPSの場合、ソルトサイズの計算に使用できます
 883
 884    _Example_
 885    \code
 886    ret = wc_InitRsaKey(&key, NULL);
 887    if (ret == 0) {
 888        ret = wc_InitRng(&rng);
 889    } else return -1;
 890    if (ret == 0) {
 891        ret = wc_RsaSetRNG(&key, &rng);
 892    } else return -1;
 893    if (ret == 0) {
 894            ret = wc_MakeRsaKey(&key, 2048, WC_RSA_EXPONENT, &rng);
 895    } else return -1;
 896    if (ret == 0) {
 897        digestSz = wc_HashGetDigestSize(WC_HASH_TYPE_SHA256);
 898        ret = wc_Hash(WC_HASH_TYPE_SHA256, message, sz, digest, digestSz);
 899    } else return -1;
 900    ret = wc_RsaPSS_Sign(digest, digestSz, pSignature, sizeof(pSignature),
 901            WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key, &rng);
 902    if (ret > 0 ){
 903        sz = ret;
 904    } else return -1;
 905
 906    verify = wc_RsaPSS_Verify(pSignature, sz, out, outLen,
 907            WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key);
 908    if (verify <= 0)return -1;
 909
 910    ret = wc_RsaPSS_CheckPadding_ex(digest, digestSz, out, verify, hash, saltLen, 0);
 911
 912    wc_FreeRsaKey(&key);
 913    wc_FreeRng(&rng);
 914    \endcode
 915
 916    \sa wc_RsaPSS_Sign
 917    \sa wc_RsaPSS_Verify
 918    \sa wc_RsaPSS_VerifyInline
 919    \sa wc_RsaPSS_VerifyCheck
 920    \sa wc_RsaPSS_VerifyCheck_ex
 921    \sa wc_RsaPSS_VerifyCheckInline
 922    \sa wc_RsaPSS_VerifyCheckInline_ex
 923    \sa wc_RsaPSS_CheckPadding
 924*/
 925int  wc_RsaPSS_CheckPadding_ex(const byte* in, word32 inLen, const byte* sig,
 926                word32 sigSz, enum wc_HashType hashType, int saltLen, int bits);
 927/*!
 928    \ingroup RSA
 929
 930    \brief 提供されたキー構造体の暗号化サイズを返します。
 931
 932    \return Success 提供されたキー構造体の暗号化サイズ。
 933
 934    \param key 検証に使用するキー。
 935
 936    _Example_
 937    \code
 938    int sz = wc_RsaEncryptSize(&key);
 939    \endcode
 940
 941    \sa wc_InitRsaKey
 942    \sa wc_InitRsaKey_ex
 943    \sa wc_MakeRsaKey
 944*/
 945int  wc_RsaEncryptSize(const RsaKey* key);
 946
 947/*!
 948    \ingroup RSA
 949
 950    \brief この関数は、DER形式のRSA秘密鍵を解析し、秘密鍵を抽出して、指定されたRsaKey構造体に格納します。また、idxに解析された距離を設定します。
 951
 952    \return 0 DERエンコードされた入力から秘密鍵を正常に解析した場合に返されます
 953    \return ASN_PARSE_E 入力バッファから秘密鍵を解析する際にエラーがある場合に返されます。これは、入力秘密鍵がASN.1標準に従って適切にフォーマットされていない場合に発生する可能性があります
 954    \return ASN_RSA_KEY_E RSAキー入力の秘密鍵要素を読み取る際にエラーがある場合に返されます
 955
 956    \param input デコードするDER形式の秘密鍵を含むバッファへのポインタ
 957    \param inOutIdx キーが始まるバッファ内のインデックスへのポインタ（通常は0）。この関数の副作用として、inOutIdxは入力バッファを通じて解析された距離を格納します
 958    \param key デコードされた秘密鍵を格納するRsaKey構造体へのポインタ
 959    \param inSz 入力バッファのサイズ
 960
 961    _Example_
 962    \code
 963    RsaKey enc;
 964    word32 idx = 0;
 965    int ret = 0;
 966    byte der[] = { // DERエンコードされたRSA秘密鍵で初期化 };
 967
 968    wc_InitRsaKey(&enc, NULL); // ヒープヒントを使用しない。カスタムメモリなし
 969    ret = wc_RsaPrivateKeyDecode(der, &idx, &enc, sizeof(der));
 970    if( ret != 0 ) {
 971    	// 秘密鍵の解析エラー
 972    }
 973    \endcode
 974
 975    \sa wc_RsaPublicKeyDecode
 976    \sa wc_MakeRsaKey
 977*/
 978int  wc_RsaPrivateKeyDecode(const byte* input, word32* inOutIdx,
 979                            RsaKey* key, word32 inSz);
 980
 981/*!
 982    \ingroup RSA
 983
 984    \brief この関数は、DER形式のRSA公開鍵を解析し、公開鍵を抽出して、指定されたRsaKey構造体に格納します。また、idxに解析された距離を設定します。
 985
 986    \return 0 DERエンコードされた入力から公開鍵を正常に解析した場合に返されます
 987    \return ASN_PARSE_E 入力バッファから公開鍵を解析する際にエラーがある場合に返されます。これは、入力公開鍵がASN.1標準に従って適切にフォーマットされていない場合に発生する可能性があります
 988    \return ASN_OBJECT_ID_E ASN.1オブジェクトIDがRSA公開鍵のものと一致しない場合に返されます
 989    \return ASN_EXPECT_0_E 入力キーがASN.1標準に従って正しくフォーマットされていない場合に返されます
 990    \return ASN_BITSTR_E 入力キーがASN.1標準に従って正しくフォーマットされていない場合に返されます
 991    \return ASN_RSA_KEY_E RSAキー入力の公開鍵要素を読み取る際にエラーがある場合に返されます
 992
 993    \param input デコードする入力DERエンコードされたRSA公開鍵を含むバッファへのポインタ
 994    \param inOutIdx キーが始まるバッファ内のインデックスへのポインタ（通常は0）。この関数の副作用として、inOutIdxは入力バッファを通じて解析された距離を格納します
 995    \param key デコードされた公開鍵を格納するRsaKey構造体へのポインタ
 996    \param inSz 入力バッファのサイズ
 997
 998    _Example_
 999    \code
1000    RsaKey pub;
1001    word32 idx = 0;
1002    int ret = 0;
1003    byte der[] = { // DERエンコードされたRSA公開鍵で初期化 };
1004
1005    wc_InitRsaKey(&pub, NULL); // ヒープヒントを使用しない。カスタムメモリなし
1006    ret = wc_RsaPublicKeyDecode(der, &idx, &pub, sizeof(der));
1007    if( ret != 0 ) {
1008    	// 公開鍵の解析エラー
1009    }
1010    \endcode
1011
1012    \sa wc_RsaPublicKeyDecodeRaw
1013*/
1014int  wc_RsaPublicKeyDecode(const byte* input, word32* inOutIdx,
1015                           RsaKey* key, word32 inSz);
1016
1017/*!
1018    \ingroup RSA
1019
1020    \brief この関数は、RSA公開鍵の生の要素をデコードし、公開モジュラス（n）と指数（e）を受け取ります。これらの生の要素を提供されたRsaKey構造体に格納し、暗号化/復号プロセスでそれらを使用できるようにします。
1021
1022    \return 0 公開鍵の生の要素をRsaKey構造体に正常にデコードした場合に返されます
1023    \return BAD_FUNC_ARG いずれかの入力引数がNULLと評価された場合に返されます
1024    \return MP_INIT_E 多精度整数（mp_int）ライブラリで使用するために整数を初期化する際にエラーがある場合に返されます
1025    \return ASN_GETINT_E 提供されたRSAキー要素（nまたはe）のいずれかを読み取る際にエラーがある場合に返されます
1026
1027    \param n 公開RSAキーの生のモジュラスパラメータを含むバッファへのポインタ
1028    \param nSz nを含むバッファのサイズ
1029    \param e 公開RSAキーの生の指数パラメータを含むバッファへのポインタ
1030    \param eSz eを含むバッファのサイズ
1031    \param key 提供された公開鍵要素で初期化するRsaKey構造体へのポインタ
1032
1033    _Example_
1034    \code
1035    RsaKey pub;
1036    int ret = 0;
1037    byte n[] = { // 受信した公開鍵のn成分で初期化 };
1038    byte e[] = { // 受信した公開鍵のe成分で初期化 };
1039
1040    wc_InitRsaKey(&pub, NULL); // ヒープヒントを使用しない。カスタムメモリなし
1041    ret = wc_RsaPublicKeyDecodeRaw(n, sizeof(n), e, sizeof(e), &pub);
1042    if( ret != 0 ) {
1043    	// 公開鍵要素の解析エラー
1044    }
1045    \endcode
1046
1047    \sa wc_RsaPublicKeyDecode
1048*/
1049int  wc_RsaPublicKeyDecodeRaw(const byte* n, word32 nSz,
1050                                        const byte* e, word32 eSz, RsaKey* key);
1051
1052/*!
1053    \ingroup RSA
1054
1055    \brief この関数は、RsaKeyキーをDER形式に変換します。結果はoutputに書き込まれ、書き込まれたバイト数を返します。
1056
1057    \return >0 成功、書き込まれたバイト数。
1058    \return BAD_FUNC_ARG keyまたはoutputがnullの場合、またはkey->typeがRSA_PRIVATEでない場合、またはinLenが出力バッファに対して十分な大きさでない場合に返されます。
1059    \return MEMORY_E メモリの割り当て中にエラーがある場合に返されます。
1060
1061    \param key 初期化されたRsaKey構造体。
1062    \param output 出力バッファへのポインタ。
1063    \param inLen 出力バッファのサイズ。
1064
1065    _Example_
1066    \code
1067    byte* der;
1068    // derにメモリを割り当て
1069    int derSz = // derに割り当てられたメモリの量;
1070    RsaKey key;
1071    WC_RNG rng;
1072    long e = 65537; // 指数に使用する標準値
1073    ret = wc_MakeRsaKey(&key, 2048, e, &rng); // 2048ビット長の秘密鍵を生成
1074    wc_InitRsaKey(&key, NULL);
1075    wc_InitRng(&rng);
1076    if(wc_RsaKeyToDer(&key, der, derSz) != 0)
1077    {
1078        // スローされたエラーを処理
1079    }
1080    \endcode
1081
1082    \sa wc_RsaKeyToPublicDer
1083    \sa wc_InitRsaKey
1084    \sa wc_MakeRsaKey
1085    \sa wc_InitRng
1086*/
1087int wc_RsaKeyToDer(RsaKey* key, byte* output, word32 inLen);
1088
1089/*!
1090    \ingroup RSA
1091
1092    \brief この関数は、使用するパディングを選択できるようにしながら、RSA暗号化を実行します。
1093    \return size 暗号化に成功した場合、暗号化されたバッファのサイズが返されます
1094    \return RSA_BUFFER_E RSAバッファエラー、出力が小さすぎるか入力が大きすぎます
1095
1096    \param in 暗号化するバッファへのポインタ
1097    \param inLen 暗号化するバッファの長さ
1098    \param out 作成された暗号化されたメッセージ
1099    \param outLen 暗号化されたメッセージを保持するために利用可能なバッファの長さ
1100    \param key 初期化されたRSAキー構造体
1101    \param rng 初期化されたWC_RNG構造体
1102    \param type 使用するパディングのタイプ（WC_RSA_OAEP_PADまたはWC_RSA_PKCSV15_PAD）
1103    \param hash 使用するハッシュのタイプ（選択肢はhash.hにあります）
1104    \param mgf 使用するマスク生成関数のタイプ
1105    \param label 暗号化されたメッセージに関連付けるオプションのラベル
1106    \param labelSz 使用されるオプションのラベルのサイズ
1107
1108    _Example_
1109    \code
1110    WC_RNG rng;
1111    RsaKey key;
1112    byte in[] = "I use Turing Machines to ask questions"
1113    byte out[256];
1114    int ret;
1115    …
1116
1117    ret = wc_RsaPublicEncrypt_ex(in, sizeof(in), out, sizeof(out), &key, &rng,
1118    WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA, WC_MGF1SHA1, NULL, 0);
1119    if (ret < 0) {
1120	    // エラーを処理
1121    }
1122    \endcode
1123
1124    \sa wc_RsaPublicEncrypt
1125    \sa wc_RsaPrivateDecrypt_ex
1126*/
1127int  wc_RsaPublicEncrypt_ex(const byte* in, word32 inLen, byte* out,
1128                   word32 outLen, RsaKey* key, WC_RNG* rng, int type,
1129                   enum wc_HashType hash, int mgf, byte* label, word32 labelSz);
1130
1131/*!
1132    \ingroup RSA
1133
1134    \brief この関数は、RSAを使用してメッセージを復号し、どのパディングタイプを使用するかのオプションを提供します。
1135
1136    \return size 復号に成功した場合、復号されたメッセージのサイズが返されます。
1137    \return MEMORY_E 必要な配列をmallocするのに十分なメモリがシステムにない場合に返されます。
1138    \return BAD_FUNC_ARG 関数に不正な引数が渡された場合に返されます。
1139
1140    \param in 復号するバッファへのポインタ
1141    \param inLen 復号するバッファの長さ
1142    \param out 作成された復号されたメッセージ
1143    \param outLen 復号されたメッセージを保持するために利用可能なバッファの長さ
1144    \param key 初期化されたRSAキー構造体
1145    \param type 使用するパディングのタイプ（WC_RSA_OAEP_PADまたはWC_RSA_PKCSV15_PAD）
1146    \param hash 使用するハッシュのタイプ（選択肢はhash.hにあります）
1147    \param mgf 使用するマスク生成関数のタイプ
1148    \param label 暗号化されたメッセージに関連付けるオプションのラベル
1149    \param labelSz 使用されるオプションのラベルのサイズ
1150
1151    _Example_
1152    \code
1153    WC_RNG rng;
1154    RsaKey key;
1155    byte in[] = "I use Turing Machines to ask questions"
1156    byte out[256];
1157    byte plain[256];
1158    int ret;
1159    …
1160    ret = wc_RsaPublicEncrypt_ex(in, sizeof(in), out, sizeof(out), &key,
1161    &rng, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA, WC_MGF1SHA1, NULL, 0);
1162    if (ret < 0) {
1163	    // エラーを処理
1164    }
1165    …
1166    ret = wc_RsaPrivateDecrypt_ex(out, ret, plain, sizeof(plain), &key,
1167    WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA, WC_MGF1SHA1, NULL, 0);
1168
1169    if (ret < 0) {
1170	    // エラーを処理
1171    }
1172    \endcode
1173
1174    \sa なし
1175*/
1176int  wc_RsaPrivateDecrypt_ex(const byte* in, word32 inLen,
1177                   byte* out, word32 outLen, RsaKey* key, int type,
1178                   enum wc_HashType hash, int mgf, byte* label, word32 labelSz);
1179
1180/*!
1181    \ingroup RSA
1182
1183    \brief この関数は、RSAを使用してメッセージをインラインで復号し、どのパディングタイプを使用するかのオプションを提供します。inバッファは呼び出し後に復号されたメッセージを含み、outバイトポインタは平文がある「in」バッファ内の場所を指します。
1184
1185    \return size 復号に成功した場合、復号されたメッセージのサイズが返されます。
1186    \return MEMORY_E: 必要な配列をmallocするのに十分なメモリがシステムにない場合に返されます。
1187    \return RSA_PAD_E: パディングにエラーがあった場合に返されます。
1188    \return BAD_PADDING_E: パディングを解析中にエラーが発生した場合に返されます。
1189    \return BAD_FUNC_ARG: 関数に不正な引数が渡された場合に返されます。
1190
1191    \param in 復号するバッファへのポインタ
1192    \param inLen 復号するバッファの長さ
1193    \param out 「in」バッファ内の復号されたメッセージの場所へのポインタ
1194    \param key 初期化されたRSAキー構造体
1195    \param type 使用するパディングのタイプ（WC_RSA_OAEP_PADまたはWC_RSA_PKCSV15_PAD）
1196    \param hash 使用するハッシュのタイプ（選択肢はhash.hにあります）
1197    \param mgf 使用するマスク生成関数のタイプ
1198    \param label 暗号化されたメッセージに関連付けるオプションのラベル
1199    \param labelSz 使用されるオプションのラベルのサイズ
1200
1201    _Example_
1202    \code
1203    WC_RNG rng;
1204    RsaKey key;
1205    byte in[] = "I use Turing Machines to ask questions"
1206    byte out[256];
1207    byte* plain;
1208    int ret;
1209    …
1210    ret = wc_RsaPublicEncrypt_ex(in, sizeof(in), out, sizeof(out), &key,
1211    &rng, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA, WC_MGF1SHA1, NULL, 0);
1212
1213    if (ret < 0) {
1214	    // エラーを処理
1215    }
1216    …
1217    ret = wc_RsaPrivateDecryptInline_ex(out, ret, &plain, &key,
1218    WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA, WC_MGF1SHA1, NULL, 0);
1219
1220    if (ret < 0) {
1221	    // エラーを処理
1222    }
1223    \endcode
1224
1225    \sa なし
1226*/
1227int  wc_RsaPrivateDecryptInline_ex(byte* in, word32 inLen,
1228                      byte** out, RsaKey* key, int type, enum wc_HashType hash,
1229                      int mgf, byte* label, word32 labelSz);
1230
1231/*!
1232    \ingroup RSA
1233
1234    \brief RsaKey構造体をRSAアルゴリズムに使用される個々の要素（e、n）に展開します。
1235
1236    \return 0 関数がエラーなく正常に実行された場合に返されます。
1237    \return BAD_FUNC_ARG: いずれかのパラメータがnull値で渡された場合に返されます。
1238    \return RSA_BUFFER_E: 渡されたeまたはnバッファが正しいサイズでない場合に返されます。
1239    \return MP_MEM: 内部関数にメモリエラーがある場合に返されます。
1240    \return MP_VAL: 内部関数の引数が無効な場合に返されます。
1241
1242    \param key 検証に使用するキー。
1243    \param e eの値のバッファ。eはRSAモジュラー演算における大きな正の整数です。
1244    \param eSz eバッファのサイズ。
1245    \param n nの値のバッファ。nはRSAモジュラー演算における大きな正の整数です。
1246    \param nSz nバッファのサイズ。
1247
1248    _Example_
1249    \code
1250    Rsa key; // 有効なRSAキー。
1251    byte e[ バッファサイズ 例：256 ];
1252    byte n[256];
1253    int ret;
1254    word32 eSz = sizeof(e);
1255    word32 nSz = sizeof(n);
1256    ...
1257    ret = wc_RsaFlattenPublicKey(&key, e, &eSz, n, &nSz);
1258    if (ret != 0) {
1259    	// 失敗ケース。
1260    }
1261    \endcode
1262
1263    \sa wc_InitRsaKey
1264    \sa wc_InitRsaKey_ex
1265    \sa wc_MakeRsaKey
1266*/
1267int  wc_RsaFlattenPublicKey(const RsaKey* key, byte* e, word32* eSz, byte* n,
1268                            word32* nSz);
1269
1270/*!
1271    \ingroup RSA
1272
1273    \brief RSA公開鍵をDER形式に変換します。outputに書き込み、書き込まれたバイト数を返します。
1274
1275    \return >0 成功、書き込まれたバイト数。
1276    \return BAD_FUNC_ARG keyまたはoutputがnullの場合に返されます。
1277    \return MEMORY_E メモリの割り当て中にエラーが発生した場合に返されます。
1278    \return <0 エラー
1279
1280    \param key 変換するRSAキー構造体。
1281    \param output DERを保持する出力バッファ。（NULLの場合は長さのみを返します）
1282    \param inLen バッファの長さ。
1283
1284    _Example_
1285    \code
1286    RsaKey key;
1287
1288    wc_InitRsaKey(&key, NULL);
1289    // キーを使用
1290
1291    const int BUFFER_SIZE = 1024; // バッファに適切なサイズ
1292    byte output[BUFFER_SIZE];
1293    if (wc_RsaKeyToPublicDer(&key, output, sizeof(output)) != 0) {
1294        // エラーを処理
1295    }
1296    \endcode
1297
1298    \sa wc_RsaPublicKeyDerSize
1299    \sa wc_RsaKeyToPublicDer_ex
1300    \sa wc_InitRsaKey
1301*/
1302int wc_RsaKeyToPublicDer(RsaKey* key, byte* output, word32 inLen);
1303
1304/*!
1305    \ingroup RSA
1306
1307    \brief RSA公開鍵をDER形式に変換します。outputに書き込み、書き込まれたバイト数を返します。with_headerが0の場合、（seq + n + e）のみがASN.1 DER形式で返され、ヘッダーは除外されます。
1308
1309    \return >0 成功、書き込まれたバイト数。
1310    \return BAD_FUNC_ARG keyまたはoutputがnullの場合に返されます。
1311    \return MEMORY_E メモリの割り当て中にエラーが発生した場合に返されます。
1312    \return <0 エラー
1313
1314    \param key 変換するRSAキー構造体。
1315    \param output DERを保持する出力バッファ。（NULLの場合は長さのみを返します）
1316    \param inLen バッファの長さ。
1317
1318    _Example_
1319    \code
1320    RsaKey key;
1321
1322    wc_InitRsaKey(&key, NULL);
1323    // キーを使用
1324
1325    const int BUFFER_SIZE = 1024; // バッファに適切なサイズ
1326    byte output[BUFFER_SIZE];
1327    if (wc_RsaKeyToPublicDer_ex(&key, output, sizeof(output), 0) != 0) {
1328        // エラーを処理
1329    }
1330    \endcode
1331
1332    \sa wc_RsaPublicKeyDerSize
1333    \sa wc_RsaKeyToPublicDer
1334    \sa wc_InitRsaKey
1335*/
1336int wc_RsaKeyToPublicDer_ex(RsaKey* key, byte* output, word32 inLen,
1337    int with_header);
1338
1339/*!
1340    \ingroup RSA
1341
1342    \brief この関数は、長さsize（ビット単位）と指定された指数（e）のRSA秘密鍵を生成します。その後、このキーを提供されたRsaKey構造体に格納し、暗号化/復号に使用できるようにします。eに使用する安全な数値は65537です。sizeはRSA_MIN_SIZE以上かつRSA_MAX_SIZE以下である必要があります。この関数を使用するには、コンパイル時にオプションWOLFSSL_KEY_GENを有効にする必要があります。./configureを使用する場合は、--enable-keygenで実現できます。
1343
1344    \return 0 RSA秘密鍵の生成に成功した場合に返されます
1345    \return BAD_FUNC_ARG いずれかの入力引数がNULLの場合、sizeパラメータが必要な境界外にある場合、またはeが誤って選択された場合に返されます
1346    \return RNG_FAILURE_E 提供されたRNG構造体を使用してランダムブロックを生成する際にエラーがある場合に返されます
1347    \return MP_INIT_E
1348    \return MP_READ_E RSAキーの生成中に使用される数学ライブラリにエラーがある場合に返される可能性があります
1349    \return MP_CMP_E RSAキーの生成中に使用される数学ライブラリにエラーがある場合に返される可能性があります
1350    \return MP_INVMOD_E RSAキーの生成中に使用される数学ライブラリにエラーがある場合に返される可能性があります
1351    \return MP_EXPTMOD_E RSAキーの生成中に使用される数学ライブラリにエラーがある場合に返される可能性があります
1352    \return MP_MOD_E RSAキーの生成中に使用される数学ライブラリにエラーがある場合に返される可能性があります
1353    \return MP_MUL_E RSAキーの生成中に使用される数学ライブラリにエラーがある場合に返される可能性があります
1354    \return MP_ADD_E RSAキーの生成中に使用される数学ライブラリにエラーがある場合に返される可能性があります
1355    \return MP_MULMOD_E RSAキーの生成中に使用される数学ライブラリにエラーがある場合に返される可能性があります
1356    \return MP_TO_E RSAキーの生成中に使用される数学ライブラリにエラーがある場合に返される可能性があります
1357    \return MP_MEM RSAキーの生成中に使用される数学ライブラリにエラーがある場合に返される可能性があります
1358    \return MP_ZERO_E RSAキーの生成中に使用される数学ライブラリにエラーがある場合に返される可能性があります
1359
1360    \param key 生成された秘密鍵を格納するRsaKey構造体へのポインタ
1361    \param size 希望するキーの長さ（ビット単位）。RSA_MIN_SIZEより大きくRSA_MAX_SIZEより小さい必要があります
1362    \param e キーを生成するために使用する指数パラメータ。安全な選択肢は65537です
1363    \param rng キーを作成する際の乱数生成に使用するRNG構造体へのポインタ
1364
1365    _Example_
1366    \code
1367    RsaKey priv;
1368    WC_RNG rng;
1369    int ret = 0;
1370    long e = 65537; // 指数に使用する標準値
1371
1372    wc_InitRsaKey(&priv, NULL); // ヒープヒントを使用しない。カスタムメモリなし
1373    wc_InitRng(&rng);
1374    // 2048ビット長の秘密鍵を生成
1375    ret = wc_MakeRsaKey(&priv, 2048, e, &rng);
1376    if( ret != 0 ) {
1377	    // 秘密鍵の生成エラー
1378    }
1379    \endcode
1380
1381    \sa なし
1382*/
1383int wc_MakeRsaKey(RsaKey* key, int size, long e, WC_RNG* rng);
1384
1385/*!
1386    \ingroup RSA
1387
1388    \brief この関数は、ノンブロッキングRSAコンテキストを設定します。RsaNbコンテキストが設定されると、RSA関数を多くの小さな操作に分割する、高速数学ベースのノンブロッキングexptmodが有効になります。WC_RSA_NONBLOCKが定義されている場合に有効になります。
1389
1390    \return 0 成功
1391    \return BAD_FUNC_ARG keyまたはnbがnullの場合に返されます。
1392
1393    \param key RSAキー構造体
1394    \param nb このRSAキーが使用するRSAノンブロッキング構造体。
1395
1396    _Example_
1397    \code
1398    int ret, count = 0;
1399    RsaKey key;
1400    RsaNb  nb;
1401
1402    wc_InitRsaKey(&key, NULL);
1403
1404    // ノンブロッキングRSAモードを有効化 - コンテキストを提供
1405    ret = wc_RsaSetNonBlock(key, &nb);
1406    if (ret != 0)
1407        return ret;
1408
1409    do {
1410        ret = wc_RsaSSL_Sign(in, inLen, out, outSz, key, rng);
1411        count++; // ブロック回数を追跡
1412        if (ret == FP_WOULDBLOCK) {
1413            // ここで「その他の」作業を実行
1414        }
1415    } while (ret == FP_WOULDBLOCK);
1416    if (ret < 0) {
1417        return ret;
1418    }
1419
1420    printf("RSAノンブロック署名: サイズ %d、%d回\n", ret, count);
1421    \endcode
1422
1423    \sa wc_RsaSetNonBlockTime
1424*/
1425int wc_RsaSetNonBlock(RsaKey* key, RsaNb* nb);
1426
1427/*!
1428    \ingroup RSA
1429
1430    \brief この関数は、最大ブロッキング時間をマイクロ秒単位で設定します。CPU速度（メガヘルツ単位）とともに事前計算されたテーブル（tfm.c exptModNbInstを参照）を使用して、次の操作が提供された最大ブロッキング時間内に完了できるかどうかを判断します。WC_RSA_NONBLOCK_TIMEが定義されている場合に有効になります。
1431
1432    \return 0 成功
1433    \return BAD_FUNC_ARG keyがnullの場合、またはwc_RsaSetNonBlockが事前に呼び出されておらずkey->nbがnullの場合に返されます。
1434
1435    \param key RSAキー構造体。
1436    \param maxBlockUs 最大ブロック時間（マイクロ秒）。
1437    \param cpuMHz CPU速度（メガヘルツ単位）。
1438
1439    _Example_
1440    \code
1441    RsaKey key;
1442    RsaNb  nb;
1443
1444    wc_InitRsaKey(&key, NULL);
1445    wc_RsaSetNonBlock(key, &nb);
1446    wc_RsaSetNonBlockTime(&key, 4000, 160); // Block Max = 4 ms、CPU = 160MHz
1447
1448    \endcode
1449
1450    \sa wc_RsaSetNonBlock
1451*/
1452int wc_RsaSetNonBlockTime(RsaKey* key, word32 maxBlockUs,
1453    word32 cpuMHz);