srp.h

Go to the documentation of this file.

/* srp.h
 *
 * Copyright (C) 2006-2020 wolfSSL Inc.
 *
 * This file is part of wolfSSL.
 *
 * wolfSSL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * wolfSSL is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
 */
 
#ifdef WOLFCRYPT_HAVE_SRP
 
#ifndef WOLFCRYPT_SRP_H
#define WOLFCRYPT_SRP_H
 
#include <wolfssl/wolfcrypt/types.h>
#include <wolfssl/wolfcrypt/sha.h>
#include <wolfssl/wolfcrypt/sha256.h>
#include <wolfssl/wolfcrypt/sha512.h>
#include <wolfssl/wolfcrypt/integer.h>
 
#ifdef __cplusplus
    extern "C" {
#endif
 
/* Select the largest available hash for the buffer size. */
#if defined(WOLFSSL_SHA512)
    #define SRP_MAX_DIGEST_SIZE WC_SHA512_DIGEST_SIZE
#elif defined(WOLFSSL_SHA384)
    #define SRP_MAX_DIGEST_SIZE WC_SHA384_DIGEST_SIZE
#elif !defined(NO_SHA256)
    #define SRP_MAX_DIGEST_SIZE WC_SHA256_DIGEST_SIZE
#elif !defined(NO_SHA)
    #define SRP_MAX_DIGEST_SIZE WC_SHA_DIGEST_SIZE
#else
    #error "You have to have some kind of SHA hash if you want to use SRP."
#endif
 
/* Set the minimum number of bits acceptable in an SRP modulus */
#define SRP_MODULUS_MIN_BITS 512
 
/* Set the minimum number of bits acceptable for private keys (RFC 5054) */
#define SRP_PRIVATE_KEY_MIN_BITS 256
 
/* salt size for SRP password */
#define SRP_SALT_SIZE  16
 
typedef enum {
    SRP_CLIENT_SIDE  = 0,
    SRP_SERVER_SIDE  = 1,
} SrpSide;
 
typedef enum {
        SRP_TYPE_SHA    = 1,
        SRP_TYPE_SHA256 = 2,
        SRP_TYPE_SHA384 = 3,
        SRP_TYPE_SHA512 = 4,
} SrpType;
 
 
typedef struct {
    byte type;
    union {
        #ifndef NO_SHA
            wc_Sha sha;
        #endif
        #ifndef NO_SHA256
            wc_Sha256 sha256;
        #endif
        #ifdef WOLFSSL_SHA384
            wc_Sha384 sha384;
        #endif
        #ifdef WOLFSSL_SHA512
            wc_Sha512 sha512;
        #endif
    } data;
} SrpHash;
 
typedef struct Srp {
    SrpSide side;                   
    SrpType type;                   
    byte*   user;                   
    word32  userSz;                 
    byte*   salt;                   
    word32  saltSz;                 
    mp_int  N;                      
    mp_int  g;                      
    byte    k[SRP_MAX_DIGEST_SIZE]; 
    mp_int  auth;                   
    mp_int  priv;                   
    SrpHash client_proof;           
    SrpHash server_proof;           
    byte*   key;                    
    word32  keySz;                  
    int (*keyGenFunc_cb) (struct Srp* srp, byte* secret, word32 size);
    void*   heap;                   
} Srp;
 
WOLFSSL_API int wc_SrpInit(Srp* srp, SrpType type, SrpSide side);
 
WOLFSSL_API void wc_SrpTerm(Srp* srp);
 
WOLFSSL_API int wc_SrpSetUsername(Srp* srp, const byte* username, word32 size);
 
 
WOLFSSL_API int wc_SrpSetParams(Srp* srp, const byte* N,    word32 nSz,
                                          const byte* g,    word32 gSz,
                                          const byte* salt, word32 saltSz);
 
WOLFSSL_API int wc_SrpSetPassword(Srp* srp, const byte* password, word32 size);
 
WOLFSSL_API int wc_SrpSetVerifier(Srp* srp, const byte* verifier, word32 size);
 
WOLFSSL_API int wc_SrpGetVerifier(Srp* srp, byte* verifier, word32* size);
 
WOLFSSL_API int wc_SrpSetPrivate(Srp* srp, const byte* priv, word32 size);
 
WOLFSSL_API int wc_SrpGetPublic(Srp* srp, byte* pub, word32* size);
 
 
WOLFSSL_API int wc_SrpComputeKey(Srp* srp,
                                 byte* clientPubKey, word32 clientPubKeySz,
                                 byte* serverPubKey, word32 serverPubKeySz);
 
WOLFSSL_API int wc_SrpGetProof(Srp* srp, byte* proof, word32* size);
 
WOLFSSL_API int wc_SrpVerifyPeersProof(Srp* srp, byte* proof, word32 size);
 
#ifdef __cplusplus
   } /* extern "C" */
#endif
 
#endif /* WOLFCRYPT_SRP_H */
#endif /* WOLFCRYPT_HAVE_SRP */