apps/srp.c:430: error: INTEGER_OVERFLOW_L2
  ([0, 2147483646] + 4):signed32 by call to `srp_create_user`.
Showing all 12 steps of the trace


apps/srp.c:369:50: Unknown value from: strcmp
367.           if (pp[DB_srptype][0] == DB_SRP_INDEX) {
368.               maxgN = i;
369.               if ((gNindex < 0) && (gN != NULL) && strcmp(gN, pp[DB_srpid]) == 0)
                                                        ^
370.                   gNindex = i;
371.   

apps/srp.c:430:22: Call
428.                   if (!
429.                       (gNid =
430.                        srp_create_user(user, &(row[DB_srpverifier]),
                            ^
431.                                        &(row[DB_srpsalt]),
432.                                        gNrow ? gNrow[DB_srpsalt] : gN,

apps/srp.c:154:1: Parameter `g->strlen`
  152.   }
  153.   
  154. > static char *srp_create_user(char *user, char **srp_verifier,
  155.                                char **srp_usersalt, char *g, char *N,
  156.                                char *passout, int verbose)

apps/srp.c:172:21: Call
  170.               BIO_printf(bio_err, "Creating\n user=\"%s\"\n g=\"%s\"\n N=\"%s\"\n",
  171.                          user, g, N);
  172.           if ((gNid = SRP_create_verifier(user, password, &salt,
                             ^
  173.                                           srp_verifier, N, g)) == NULL) {
  174.               BIO_printf(bio_err, "Internal error creating SRP verifier\n");

crypto/srp/srp_vfy.c:446:1: Parameter `g->strlen`
    444.    * create a verifier (*salt,*verifier,g and N are in base64)
    445.    */
    446. > char *SRP_create_verifier(const char *user, const char *pass, char **salt,
    447.                             char **verifier, const char *N, const char *g)
    448.   {

crypto/srp/srp_vfy.c:467:20: Call
    465.           N_bn_alloc = BN_bin2bn(tmp, len, NULL);
    466.           N_bn = N_bn_alloc;
    467.           if ((len = t_fromb64(tmp, sizeof(tmp) ,g)) <= 0)
                              ^
    468.               goto err;
    469.           g_bn_alloc = BN_bin2bn(tmp, len, NULL);

crypto/srp/srp_vfy.c:25:1: Parameter `src->strlen`
      23.    * Convert a base64 string into raw byte array representation.
      24.    */
      25. > static int t_fromb64(unsigned char *a, size_t alen, const char *src)
      26.   {
      27.       size_t size = strlen(src);

crypto/srp/srp_vfy.c:27:5: Assignment
      25.   static int t_fromb64(unsigned char *a, size_t alen, const char *src)
      26.   {
      27.       size_t size = strlen(src);
                ^
      28.   
      29.       /* Four bytes in src become three bytes output. */

crypto/srp/srp_vfy.c:33:12: Call
      31.           return -1;
      32.   
      33.       return EVP_DecodeBlock(a, (unsigned char *)src, (int)size);
                       ^
      34.   }
      35.   

crypto/evp/encode.c:351:1: <LHS trace>
349.   }
350.   
351. > int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n)
352.   {
353.       int i, ret = 0, a, b, c, d;

crypto/evp/encode.c:351:1: Parameter `n`
        349.   }
        350.   
        351. > int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n)
        352.   {
        353.       int i, ret = 0, a, b, c, d;

crypto/evp/encode.c:372:24: Binary operation: ([0, 2147483646] + 4):signed32 by call to `srp_create_user` 
        370.           return (-1);
        371.   
        372.       for (i = 0; i < n; i += 4) {
                                      ^
        373.           a = conv_ascii2bin(*(f++));
        374.           b = conv_ascii2bin(*(f++));
