Changeset 133 for trunk/src/sh_forward.c


Ignore:
Timestamp:
Oct 25, 2007, 12:19:05 AM (12 years ago)
Author:
rainer
Message:

Reentrant checksum/hash functions.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/sh_forward.c

    r132 r133  
    890890
    891891  static time_t timeout_val =  1;
     892  char hashbuf[KEYBUF_SIZE];
     893  char sigbuf[KEYBUF_SIZE];
    892894
    893895  SL_ENTER(_("sh_forward_try_impl"));
     
    10161018                        sh_tiger_hash((char *) &ticks,
    10171019                                      TIGER_DATA,
    1018                                       (unsigned long)sizeof(UINT32)),
     1020                                      (unsigned long)sizeof(UINT32),
     1021                                      hashbuf, sizeof(hashbuf)),
    10191022                        KEY_LEN+1);
    10201023
     
    10261029                        sh_tiger_hash(temp,
    10271030                                      TIGER_DATA,
    1028                                       (unsigned long)sl_strlen(temp)),
     1031                                      (unsigned long)sl_strlen(temp),
     1032                                      hashbuf, sizeof(hashbuf)),
    10291033                        KEY_LEN+1);
    10301034      sh_passwd (temp, NULL, NULL, foo_M1);
     
    11631167                  else /* if (0 != sh_srp_check_zero (answer)) */
    11641168                    {
    1165                       sl_strlcpy(u_real, sh_tiger_hash(head_u, TIGER_DATA, 4),
     1169                      sl_strlcpy(u_real, sh_tiger_hash(head_u, TIGER_DATA, 4,
     1170                                                       hashbuf, sizeof(hashbuf)),
    11661171                                 SH_CHALLENGE_SIZE);
    11671172                      foo_Sc = sh_srp_S_c (u_real, answer);
     
    11761181                      if (foo_Sc != NULL)
    11771182                        {
    1178                           sl_strlcpy(foo_M1,
    1179                                      sh_srp_M(foo_A,
    1180                                               answer,
    1181                                               sh_tiger_hash(foo_Sc,
    1182                                                             TIGER_DATA,
    1183                                                             sl_strlen(foo_Sc))),
    1184                                      KEY_LEN+1);
     1183                          sh_srp_M(foo_A,
     1184                                   answer,
     1185                                   sh_tiger_hash(foo_Sc,
     1186                                                 TIGER_DATA,
     1187                                                 sl_strlen(foo_Sc),
     1188                                                 hashbuf, sizeof(hashbuf)),
     1189                                   foo_M1, KEY_LEN+1);
     1190
    11851191
    11861192                          TPT(( 0, FIL__, __LINE__, _("msg=<srp:M1 = %s>\n"),
     
    12131219                          /* ------  verify M2 = H(A, M1, K) --------
    12141220                           */
     1221                          char M_buf[KEY_LEN+1];
    12151222                          M = sh_srp_M (foo_A, foo_M1,
    12161223                                        sh_tiger_hash(foo_Sc,
    12171224                                                      TIGER_DATA,
    1218                                                       sl_strlen(foo_Sc)));
     1225                                                      sl_strlen(foo_Sc),
     1226                                                      hashbuf, sizeof(hashbuf)),
     1227                                        M_buf, sizeof(M_buf)
     1228                                        );
    12191229                          if (M != NULL &&
    12201230                              0 == sl_strncmp (answer, M, KEY_LEN+1))
     
    12231233                                          sh_tiger_hash(foo_Sc,
    12241234                                                        TIGER_DATA,
    1225                                                         sl_strlen(foo_Sc)),
     1235                                                        sl_strlen(foo_Sc),
     1236                                                        hashbuf, sizeof(hashbuf)),
    12261237                                          KEY_LEN+1);
    12271238                              TPT(( 0, FIL__, __LINE__,
     
    13011312  (void) sl_strlcpy (answer, sh_util_siggen(skey->session,
    13021313                                            sh.host.name,
    1303                                             sl_strlen(sh.host.name)),
     1314                                            sl_strlen(sh.host.name),
     1315                                            sigbuf, sizeof(sigbuf)),
    13041316              KEY_LEN+1);
    13051317  TPT((0, FIL__, __LINE__, _("msg=<host %s>\n"), sh.host.name));
     
    13731385                                    sh_util_siggen (skey->session,
    13741386                                                    buffer,
    1375                                                     sl_strlen(buffer)),
     1387                                                    sl_strlen(buffer),
     1388                                                    sigbuf, sizeof(sigbuf)),
    13761389                                    KEY_LEN+1);
    13771390                  TPT((0, FIL__, __LINE__, _("msg=<sign %s.>\n"),
    13781391                       sh_util_siggen(skey->session, buffer,
    1379                                       sl_strlen(buffer))));                   
     1392                                      sl_strlen(buffer), sigbuf, sizeof(sigbuf))));                   
    13801393
    13811394                  (void) sl_strlcpy(buffer, errmsg, len);
     
    14391452                                            sh_util_siggen(skey->session,
    14401453                                                           buffer,
    1441                                                            sl_strlen(buffer)),
     1454                                                           sl_strlen(buffer),
     1455                                                           sigbuf, sizeof(sigbuf)),
    14421456                                            KEY_LEN);
    14431457                      TPT((0, FIL__, __LINE__, _("msg=<sign %s.>\n"),
    14441458                           sh_util_siggen(skey->session, buffer,
    1445                                           sl_strlen(buffer))));
     1459                                          sl_strlen(buffer), sigbuf, sizeof(sigbuf))));
    14461460
    14471461                      if (flag_err != 0)
     
    14731487                                           sh_util_siggen(skey->session,
    14741488                                                          buffer,
    1475                                                           pos),
     1489                                                          pos,
     1490                                                          sigbuf, sizeof(sigbuf)),
    14761491                                           KEY_LEN);
    14771492                             
     
    15831598                                sh_tiger_hash((char *) &ticks,
    15841599                                              TIGER_DATA,
    1585                                               (unsigned long)sizeof(UINT32)),
     1600                                              (unsigned long)sizeof(UINT32),
     1601                                              hashbuf, sizeof(hashbuf)),
    15861602                                KEY_LEN+1);
    15871603
     
    15921608              (void)sl_strlcpy(foo_M1,
    15931609                               sh_tiger_hash(buffer, TIGER_DATA,
    1594                                              (unsigned long)sl_strlen(buffer)),
     1610                                             (unsigned long)sl_strlen(buffer),
     1611                                             hashbuf, sizeof(hashbuf)),
    15951612                               KEY_LEN+1);
    15961613              memset (buffer, 0, sl_strlen(buffer));
     
    17731790  unsigned char   in[PW_LEN+1];
    17741791  int    i = 0, j, k, l = 0;
     1792  char hashbuf[KEYBUF_SIZE];
    17751793 
    17761794  if (sl_strlen(str) != (PW_LEN * 2))
     
    18001818
    18011819  sl_strlcpy ((char *)key,
    1802               sh_tiger_hash ((char*)in, TIGER_DATA, PW_LEN),
     1820              sh_tiger_hash ((char*)in, TIGER_DATA, PW_LEN,
     1821                             hashbuf, sizeof(hashbuf)),
    18031822              KEY_LEN+1);
    18041823  key[KEY_LEN] = '\0';
     
    18221841  char   in[PW_LEN];
    18231842  int    i = 0, j, k, l = 0;
     1843  char hashbuf[KEYBUF_SIZE];
    18241844 
    18251845  if (sl_strlen(str) != (PW_LEN*2))
     
    18511871      {
    18521872        sh_util_keyinit(key, KEY_LEN);
    1853         sl_strlcpy(salt, sh_tiger_hash(key, TIGER_DATA, KEY_LEN), 17);
     1873        sl_strlcpy(salt, sh_tiger_hash(key, TIGER_DATA, KEY_LEN,
     1874                                       hashbuf, sizeof(hashbuf)),
     1875                   17);
    18541876        sh_srp_x (salt, in);
    18551877        foo_v  = sh_srp_verifier ();
     
    18731895  UINT32   val[2];
    18741896  char     output[KEY_LEN+1];
     1897  char hashbuf[KEYBUF_SIZE];
    18751898
    18761899  val[0] = taus_get (&(skey->rng0[0]), &(skey->rng0[1]), &(skey->rng0[2]));
     
    18781901
    18791902  sl_strlcpy (output,
    1880               sh_tiger_hash((char *)(&val[0]), TIGER_DATA, 2*sizeof(UINT32)),
     1903              sh_tiger_hash((char *)(&val[0]), TIGER_DATA, 2*sizeof(UINT32),
     1904                            hashbuf, sizeof(hashbuf)),
    18811905              KEY_LEN);
    18821906
     
    28172841  char     * foo_Ss;
    28182842#endif
     2843  char hashbuf[KEYBUF_SIZE];
     2844  char sigbuf[KEYBUF_SIZE];
    28192845
    28202846  SL_ENTER(_("check_protocol"));
     
    29082934                          sh_util_siggen(this_client->session_key,
    29092935                                         &(conn->buf[KEY_LEN]),
    2910                                          sl_strlen(&(conn->buf[KEY_LEN]))),
     2936                                         sl_strlen(&(conn->buf[KEY_LEN])),
     2937                                         sigbuf, sizeof(sigbuf)),
    29112938                          KEY_LEN+1);
    29122939              TPT((0, FIL__, __LINE__, _("msg=<host %s>\n"),
     
    29172944                   sh_util_siggen(this_client->session_key,
    29182945                                  &(conn->buf[KEY_LEN]),
    2919                                   sl_strlen(&(conn->buf[KEY_LEN])))));
     2946                                  sl_strlen(&(conn->buf[KEY_LEN])),
     2947                                  sigbuf, sizeof(sigbuf))));
    29202948
    29212949              if (0 != sl_strncmp(conn->K, conn->buf, KEY_LEN))
     
    29532981              sl_strlcpy (conn->K,
    29542982                          sh_tiger_hash ((char *) &ticks,
    2955                                          TIGER_DATA, sizeof(UINT32)),
     2983                                         TIGER_DATA, sizeof(UINT32),
     2984                                         hashbuf, sizeof(hashbuf)),
    29562985                          KEY_LEN+1);
    29572986
     
    29853014              sl_strlcat(conn->A, conn->client_entry->session_key,
    29863015                         3*KEY_LEN+1);
    2987               sl_strlcpy (conn->K, sh_tiger_hash(conn->A,TIGER_DATA,3*KEY_LEN),
     3016              sl_strlcpy (conn->K, sh_tiger_hash(conn->A,TIGER_DATA,3*KEY_LEN,
     3017                                                 hashbuf, sizeof(hashbuf)),
    29883018                          KEY_LEN+1);
    29893019              SH_FREE(conn->A);
     
    33683398                          sh_util_siggen(this_client->session_key,
    33693399                                         &(conn->buf[KEY_LEN]),
    3370                                          sl_strlen(&(conn->buf[KEY_LEN]))),
     3400                                         sl_strlen(&(conn->buf[KEY_LEN])),
     3401                                         sigbuf, sizeof(sigbuf)),
    33713402                          KEY_LEN+1);
    33723403              TPT((0, FIL__, __LINE__, _("msg=<host %s>\n"),
     
    34843515                              sh_util_siggen(conn->client_entry->session_key,
    34853516                                             buffer,
    3486                                              sl_strlen(buffer)),
     3517                                             sl_strlen(buffer),
     3518                                             sigbuf, sizeof(sigbuf)),
    34873519                              KEY_LEN);
    34883520              TPT((0, FIL__, __LINE__, _("msg=<sign %s.>\n"),
    34893521                   sh_util_siggen(conn->client_entry->session_key,
    34903522                                  buffer,
    3491                                   sl_strlen(buffer))));
     3523                                  sl_strlen(buffer),
     3524                                  sigbuf, sizeof(sigbuf))));
    34923525
    34933526
     
    36013634                         sh_util_siggen ( conn->client_entry->session_key,
    36023635                                          buffer,
    3603                                           sl_strlen(buffer)),
     3636                                          sl_strlen(buffer),
     3637                                          sigbuf, sizeof(sigbuf)),
    36043638                         KEY_LEN+1);
    36053639             
     
    36153649                             sh_util_siggen ( conn->client_entry->session_key,
    36163650                                              &hash[KEY_LEN],
    3617                                               sl_strlen(&hash[KEY_LEN])),
     3651                                              sl_strlen(&hash[KEY_LEN]),
     3652                                              sigbuf, sizeof(sigbuf)),
    36183653                             SH_MAXMSGLEN+KEY_LEN+1);
    36193654                 
     
    36313666                   sh_util_siggen(conn->client_entry->session_key,
    36323667                                  buffer,
    3633                                   sl_strlen(buffer))));
     3668                                  sl_strlen(buffer),
     3669                                  sigbuf, sizeof(sigbuf))));
    36343670         
    36353671#ifdef SH_ENCRYPT
     
    37673803              sl_strlcpy(conn->A,
    37683804                         sh_tiger_hash((char *) &ticks,
    3769                                        TIGER_DATA, sizeof(UINT32)),
     3805                                       TIGER_DATA, sizeof(UINT32),
     3806                                       hashbuf, sizeof(hashbuf)),
    37703807                         KEY_LEN+1);
    37713808              u[0] = 'I'; u[1] = 'N'; u[2] = 'I'; u[3] = 'T'; u[4] = '\0';
     
    38493886              sl_strlcpy(hash, sh_tiger_hash (conn->M1,
    38503887                                              TIGER_DATA,
    3851                                               sl_strlen(conn->M1)), KEY_LEN+1);
     3888                                              sl_strlen(conn->M1),
     3889                                              hashbuf, sizeof(hashbuf)),
     3890                         KEY_LEN+1);
    38523891              sh_passwd (hash, conn->client_entry->verifier, NULL, conn->M1);
    38533892
     
    40844123                  u[4] = '\0';
    40854124                  sl_strlcpy(conn->challenge,
    4086                              sh_tiger_hash(u, TIGER_DATA, 4),
     4125                             sh_tiger_hash(u, TIGER_DATA, 4, hashbuf, sizeof(hashbuf)),
    40874126                             SH_CHALLENGE_SIZE);
    40884127
     
    41164155                  sl_strlcpy(conn->K,
    41174156                             sh_tiger_hash(foo_Ss, TIGER_DATA,
    4118                                            sl_strlen(foo_Ss)),
     4157                                           sl_strlen(foo_Ss),
     4158                                           hashbuf, sizeof(hashbuf)),
    41194159                             KEY_LEN+1);
    41204160
     
    41254165                    }
    41264166                  conn->M1 = SH_ALLOC(KEY_LEN+1);
    4127                   sl_strlcpy(conn->M1,
    4128                           sh_srp_M (conn->A, foo_B, conn->K),
    4129                           KEY_LEN+1);
     4167                  sh_srp_M (conn->A, foo_B, conn->K, conn->M1, KEY_LEN+1);
    41304168
    41314169                  TPT((0, FIL__, __LINE__, _("msg=<srp:Ss = %s>\n"), foo_Ss));
     
    41964234                   * send M2
    41974235                   */
     4236                  char M_buf[KEY_LEN+1];
    41984237                  sh_forward_prep_send (conn,
    4199                                         sh_srp_M (conn->A, conn->M1, conn->K),
     4238                                        sh_srp_M (conn->A, conn->M1, conn->K,
     4239                                                  M_buf, sizeof(M_buf)),
    42004240                                        KEY_LEN+1,
    42014241                                        _("PARP"),
Note: See TracChangeset for help on using the changeset viewer.