开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email客户端 > 查看源码
rpa.c
资源名称：fetchmail-5.2.7.tar.gz　[点击查看]
上传用户：xxcykj
上传日期：2007-01-04
资源大小：727k
文件大小：26k
源码类别：

Email客户端

开发平台：

Unix_Linux

rpa.c：源码内容
  1. /***********************************************************************
  2.   module:       rpa.c
  3.   program:      fetchmail
  4.   programmer:   Michael J. Palmer <106177.1156@compuserve.com>
  5.   date:         29 August 1997
  6.   compiler:     GCC 2.7.2
  7.   environment:  RedHat 4.0 Linux 2.0.18
  8.   description:  RPA authorisation code for POP3 client
  10.   The sole entry point is POP3_auth_rpa()
  11.  ***********************************************************************/
  13. #include  "config.h"
  15. #if defined(POP3_ENABLE) && defined(RPA_ENABLE)
  16. #include  <stdio.h>
  17. #include  <unistd.h>
  18. #include  <ctype.h>
  19. #include  <string.h> 
  21. #include  "socket.h"
  22. #include  "fetchmail.h"
  23. #include  "md5.h"
  24. #include  "i18n.h"
  26. #ifdef TESTMODE
  27. extern unsigned char line1[];
  28. extern unsigned char line2[];
  29. extern unsigned char line3[];
  31. extern int linecount;
  32. #endif
  34. #ifndef NO_PROTO
  35.   /* prototypes for internal functions */
  36.   static int  POP3_rpa_resp(unsigned char* argbuf, int socket );
  37.   static void LenAppend(unsigned char** pptr, int len);
  38.   static int  LenSkip(unsigned char** pptr, int rxlen);
  39.   static int  DecBase64(unsigned char* bufp);
  40.   static void EncBase64(unsigned char* bufp, int len);
  41.   static void ToUnicode(unsigned char** pptr, unsigned char delim,
  42. unsigned char* buf, int* plen, int conv);
  43.   static int  SetRealmService(unsigned char* bufp);
  44.   static void GenChallenge(unsigned char* buf, int len);
  45.   static int  DigestPassphrase(unsigned char* passphrase,
  46.        unsigned char* rbuf, int unicodeit);
  47.   static void CompUserResp();
  48.   static int  CheckUserAuth();
  49.   static void md5(unsigned char* in, int len, unsigned char* out);
  50. #endif
  52. /* RPA protocol definitions */
  54. #define         EARLYVER        "x01x00"  /* Earliest supp version */
  55. #define         LATEVER         "x03x00"  /* Latest supp version   */
  56. #define         HDR             0x60        /* ASN.1 SEQUENCE        */
  57. #define         MECH            "x06x09x60x86x48x01x86xF8x73x01x01"
  58. #define         FLAGS           "x00x01"  /* Mutual authentication */
  59. #define         STRMAX          128         /* Bytes in Unicode      */
  60. #define         Tsl             14          /* Timestamp bytelen     */
  61. #define         Pul             16          /* Passphrase digest len */
  62. #define         Cul             16          /* Usr challenge bytelen */
  63. #define         Rul             16          /* Usr response bytelen  */
  64. #define         Aul             16          /* User auth bytelen     */
  65. #define         Kusl            16          /* Session key bytelen   */
  67. #define         UNIPASS         1           /* 1=Unicode 0=iso8859   */
  68. #define         PS_RPA          42          /* Return code           */
  70. /* RPA authentication items */
  72. unsigned char   Cs[256];                    /* Service challenge     */
  73. int             Csl;                        /* Length of "    "      */
  74. unsigned char   Ts[Tsl+1];                  /* Timestamp incl      */
  75. unsigned char   Nu[STRMAX];                 /* Username in Unicode   */
  76. int             Nul;                        /* Length of " in bytes  */
  77. unsigned char   Ns[STRMAX];                 /* Service in Unicode    */
  78. int             Nsl;                        /* Length of " in bytes  */
  79. unsigned char   Nr[STRMAX];                 /* Realm in Unicode      */
  80. int             Nrl;                        /* Length of " in bytes  */
  81. unsigned char   Pu[Pul];                    /* Passphrase after MD5  */
  82. unsigned char   Cu[Cul];                    /* User challenge        */
  83. unsigned char   Ru[Rul];                    /* User response         */
  84. unsigned char   Au[Aul];                    /* User auth from Deity  */
  85. unsigned char   Kusu[Kusl];                 /* Obscured Session key  */
  86. unsigned char   Kus[Kusl];                  /* Session key           */
  88. /*********************************************************************
  89.   function:      POP3_auth_rpa
  90.   description:   send the AUTH RPA commands to the server, and
  91.                  get the server's response. Then progress through the
  92.                  RPA challenge/response protocol until we are
  93.                  (hopefully) granted authorisation.
  94.   arguments:
  95.     userid       user's id@realm e.g. myuserid@csi.com
  96.     passphrase   user's passphrase
  97.                  (upper lower or mixed case as the realm has chosen.
  98.                  spec allows various options :-(   )
  99.     socket       socket to which the server is connected.
  101.   return value:  zero if success, else non-zero.
  102.   calls:         SockPrintf, POP3_rpa_resp, EncBase64, DecBase64,
  103.                  LenAppend, GenChallenge
  104.   globals:       read outlevel.
  105.  *********************************************************************/
  107. int POP3_auth_rpa (unsigned char *userid, unsigned char *passphrase, int socket)
  108. {
  109.     int      ok,rxlen,verh,verl,i,rll;
  110.     unsigned char buf [POPBUFSIZE];
  111.     unsigned char *bufp;
  112.     int      status,aulin,kuslin;
  113.     char* stdec[4] = { N_("Success") ,
  114.        N_("Restricted user (something wrong with account)") ,
  115.        N_("Invalid userid or passphrase") ,
  116.        N_("Deity error") };
  118.     /* Initiate RPA authorisation */
  120.     SockPrintf(socket,"AUTH RPArn");
  122.     if (outlevel >= O_MONITOR)
  123. report(stdout, "> AUTH RPAn");
  125.     /* Create unicode user name in Nu.              */
  126.     /* Create MD5 digest of user's passphrase in Pu */
  128.     bufp = userid;
  129.     ToUnicode(&bufp, '@', Nu, &Nul, 1);  /* User (lowercase) */
  130.     DigestPassphrase(passphrase, Pu, UNIPASS);
  132.     /* Get + response from server (RPA ready) */
  134.     if ((ok = POP3_rpa_resp(buf,socket)) != 0)
  135.     {
  136. if (outlevel > O_SILENT && outlevel < O_MONITOR)
  137.     report(stdout, "%sn",buf);
  139. return(ok);
  140.     }
  142.     /* Assemble Token 1 in buf */
  144.     bufp    = buf;
  145.     *bufp++ = HDR;
  146.     LenAppend(&bufp,      17);
  147.     memcpy(bufp, MECH,    11); bufp += 11;
  148.     memcpy(bufp, EARLYVER, 2); bufp += 2;
  149.     memcpy(bufp, LATEVER,  2); bufp += 2;
  150.     memcpy(bufp, FLAGS,    2); bufp += 2;
  152.     /* Send Token 1, receive Token 2 */
  154.     EncBase64(buf, bufp-buf);
  155. #ifndef TESTMODE
  156.     SockPrintf(socket,"%srn",buf);
  157. #endif
  158.     if (outlevel >= O_MONITOR)
  159. report(stdout, "> %sn",buf);
  160.     if ((ok = POP3_rpa_resp(buf,socket)) != 0)
  161.     {
  162. if (outlevel > O_SILENT && outlevel < O_MONITOR)
  163.     report(stdout, "%sn",buf);
  164. return(ok);
  165.     }
  166.     if ((rxlen = DecBase64(buf)) == 0)
  167.     {
  168. if (outlevel > O_SILENT)
  169.     report(stderr, _("RPA token 2: Base64 decode errorn"));
  170. return(PS_RPA);
  171.     }
  172.     bufp = buf;
  173.     *(buf+rxlen) = 0;  /* Terminates realm list */
  174.     if (LenSkip(&bufp,rxlen) == 0) return(PS_RPA);
  176.     /* Interpret Token 2 */
  178.     verh = *(bufp++); verl = *(bufp++);
  179.     if (outlevel >= O_DEBUG)
  180. report(stdout, _("Service chose RPA version %d.%dn"),verh,verl);
  181.     Csl  = *(bufp++);
  182.     memcpy(Cs, bufp, Csl);
  183.     bufp += Csl;
  184.     if (outlevel >= O_DEBUG)
  185.     {
  186. report(stdout, _("Service challenge (l=%d):n"),Csl);
  187. for (i=0; i<Csl; i++)
  188.     report_build(stdout, "%02X ",Cs[i]);
  189. report_complete(stdout, "n");
  190.     }
  191.     memcpy(Ts, bufp, Tsl);
  192.     Ts[Tsl] = 0;
  193.     bufp += Tsl;
  194.     if (outlevel >= O_DEBUG)
  195. report(stdout, _("Service timestamp %sn"),Ts);
  196.     rll = *(bufp++) << 8; rll = rll | *(bufp++);
  197.     if ((bufp-buf+rll) != rxlen)
  198.     {
  199. if (outlevel > O_SILENT)
  200.     report(stderr, _("RPA token 2 length errorn"));
  201. return(PS_RPA);
  202.     }
  203.     if (outlevel >= O_DEBUG)
  204. report(stdout, _("Realm list: %sn"),bufp);
  205.     if (SetRealmService(bufp) != 0)
  206.     {
  207. if (outlevel > O_SILENT)
  208.     report(stderr, _("RPA error in service@realm stringn"));
  209. return(PS_RPA);
  210.     }
  212.     /* Assemble Token 3 in buf */
  214.     bufp      = buf;
  215.     *(bufp++) = HDR;
  216.     LenAppend(&bufp, 11+2+strlen(userid)+1+Cul+1+Rul );
  217.     memcpy(bufp, MECH, 11); bufp += 11;
  218.     *(bufp++) = 0;
  219.     *(bufp++) = strlen(userid);
  220.     memcpy(bufp,userid,strlen(userid)); bufp += strlen(userid);
  221.     GenChallenge(Cu,Cul);
  222.     *(bufp++) = Cul;
  223.     memcpy(bufp, Cu, Cul);  bufp += Cul;
  224.     CompUserResp();
  225.     *(bufp++) = Rul;
  226.     memcpy(bufp, Ru, Rul);  bufp += Rul;
  228.     /* Send Token 3, receive Token 4 */
  230.     EncBase64(buf,bufp-buf);
  231. #ifndef TESTMODE
  232.     SockPrintf(socket,"%srn",buf);
  233. #endif
  234.     if (outlevel >= O_MONITOR)
  235. report(stdout, "> %sn",buf);
  236.     if ((ok = POP3_rpa_resp(buf,socket)) != 0)
  237.     {
  238. if (outlevel > O_SILENT && outlevel < O_MONITOR)
  239.     report(stdout, "%sn",buf);
  240. return(ok);
  241.     }
  242.     if ((rxlen = DecBase64(buf)) == 0)
  243.     {
  244. if (outlevel > O_SILENT)
  245.     report(stderr, _("RPA token 4: Base64 decode errorn"));
  246. return(PS_RPA);
  247.     }
  248.     bufp = buf;
  249.     if (LenSkip(&bufp,rxlen) == 0) return(PS_RPA);
  251.     /* Interpret Token 4 */
  253.     aulin = *(bufp++);
  254.     if (outlevel >= O_DEBUG)
  255.     {
  256. report(stdout, _("User authentication (l=%d):n"),aulin);
  257. for (i=0; i<aulin; i++)
  258.     report_build(stdout, "%02X ",bufp[i]);
  259. report_complete(stdout, "n");
  260.     }
  261.     if (aulin == Aul) memcpy(Au, bufp, Aul);
  262.     bufp += aulin;
  263.     kuslin = *(bufp++);
  264.     if (kuslin == Kusl) memcpy(Kusu, bufp, Kusl); /* blinded */
  265.     bufp += kuslin;
  266.     if (verh == 3)
  267.     {
  268. status = *(bufp++);
  269. if (outlevel >= O_DEBUG)
  270.     report(stdout, _("RPA status: %02Xn"),status);
  271.     }
  272.     else status = 0;
  273.     if ((bufp - buf) != rxlen)
  274.     {
  275. if (outlevel > O_SILENT)
  276.     report(stderr, _("RPA token 4 length errorn"));
  277. return(PS_RPA);
  278.     }
  279.     if (status != 0)
  280.     {
  281. if (outlevel > O_SILENT)
  282.     if (status < 4)
  283. report(stderr, _("RPA rejects you: %sn"),_(stdec[status]));
  284.     else
  285. report(stderr, _("RPA rejects you, reason unknownn"));
  286. return(PS_AUTHFAIL);
  287.     }
  288.     if (Aul != aulin)
  289.     {
  290. report(stderr, 
  291.        _("RPA User Authentication length error: %dn"),aulin);
  292. return(PS_RPA);
  293.     }
  294.     if (Kusl != kuslin)
  295.     {
  296. report(stderr, _("RPA Session key length error: %dn"),kuslin);
  297. return(PS_RPA);
  298.     }
  299.     if (CheckUserAuth() != 0)
  300.     {
  301. if (outlevel > O_SILENT)
  302.     report(stderr, _("RPA _service_ auth fail. Spoof server?n"));
  303. return(PS_AUTHFAIL);
  304.     }
  305.     if (outlevel >= O_DEBUG)
  306.     {
  307. report(stdout, _("Session key established:n"));
  308. for (i=0; i<Kusl; i++)
  309.     report_build(stdout, "%02X ",Kus[i]);
  310. report_complete(stdout, "n");
  311.     }
  313.     /* Assemble Token 5 in buf and send (not in ver 2 though)  */
  314.     /* Version 3.0 definitely replies with +OK to this. I have */
  315.     /* no idea what sort of response previous versions gave.   */
  317.     if (verh != 2)
  318.     {
  319. bufp      = buf;
  320. *(bufp++) = HDR;
  321. LenAppend(&bufp, 1 );
  322. *(bufp++) = 0x42;
  323. EncBase64(buf,bufp-buf);
  324. #ifndef TESTMODE
  325. SockPrintf(socket,"%srn",buf);
  326. #endif
  327. if (outlevel >= O_MONITOR)
  328.     report(stdout, "> %sn",buf);
  329. if ((ok = POP3_rpa_resp(buf,socket)) != 0)
  330. {
  331.     if (outlevel > O_SILENT && outlevel < O_MONITOR)
  332. report(stdout, "%sn",buf);
  333.     return(ok);
  334. }
  335.     }
  337.     if (outlevel > O_SILENT)
  338. report(stdout, _("RPA authorisation completen"));
  340.     return(PS_SUCCESS);
  341. }
  344. /*********************************************************************
  345.   function:      POP3_rpa_resp
  346.   description:   get the server's response to an RPA action.
  347.                  Return received base64 string if successful
  348.   arguments:
  349.     argbuf       buffer to receive the string.
  350.     socket       socket to which the server is connected.
  352.   return value:  zero if okay, else return code.
  353.   calls:         SockGets
  354.   globals:       reads outlevel.
  355.  *********************************************************************/
  357. static int POP3_rpa_resp (argbuf,socket)
  358. unsigned char *argbuf;
  359. int socket;
  360. {
  361.     int ok;
  362.     char buf [POPBUFSIZE];
  363.     char *bufp;
  364.     int sockrc;
  366.     if (outlevel >= O_DEBUG)
  367. report(stdout,  _("Get responsen"));
  368. #ifndef TESTMODE
  369.     sockrc = gen_recv(socket, buf, sizeof(buf));
  370. #else
  371.     linecount++;
  372.     if (linecount == 1) strcpy(buf,line1);
  373.     if (linecount == 2) strcpy(buf,line2);
  374.     if (linecount == 3) strcpy(buf,line3);
  375. /*  report(stdout, "--> "); fflush(stderr);  */
  376. /*  scanf("%s",&buf)                         */
  377.     sockrc = PS_SUCCESS;
  378. #endif
  379.     if (sockrc == PS_SUCCESS) {
  380. bufp = buf;
  381. if ((*buf) == '+')
  382. {
  383.     bufp++;
  384. /*      if (*bufp == ' ') bufp++; */
  385.     if (argbuf != NULL)
  386. strcpy(argbuf,bufp);
  387.     ok=0;
  388. }
  389. else if (strcmp(buf,"-ERR") == 0)
  390.     ok = PS_ERROR;
  391. else ok = PS_PROTOCOL;
  393.     }
  394.     else
  395. ok = PS_SOCKET;
  396.     if (outlevel >= O_DEBUG)
  397. report(stdout,  _("Get response return %d [%s]n"), ok, buf);
  398.     buf[sockrc] = 0;
  399.     return(ok);
  400. }
  402. /*********************************************************************
  403.   function:      LenAppend
  404.   description:   Store token length encoded as per ASN.1 DER rules
  405.                  buffer pointer stepped on appropriately.
  406.                  Copes with numbers up to 32767 at least.
  407.   arguments:
  408.     buf          pointer to buffer to receive result
  409.     len          length value to encode
  411.   return value:  none
  412.   calls:         none
  413.   globals:       none
  414.  *********************************************************************/
  416. static void LenAppend(pptr,len)
  417. unsigned char **pptr;
  418. int  len;
  419. {
  420.     if (len < 0x80)
  421.     {
  422. **pptr = len; (*pptr)++;
  423.     }
  424.     else if (len < 0x100)
  425.     {
  426. **pptr = 0x81; (*pptr)++;
  427. **pptr = len;  (*pptr)++;
  428.     }
  429.     else
  430.     {
  431. **pptr = 0x82;       (*pptr)++;
  432. **pptr = len >> 8;   (*pptr)++;
  433. **pptr = len & 0xFF; (*pptr)++;
  434.     }
  435. }
  437. /*********************************************************************
  438.   function:      LenSkip
  439.   description:   Check token header, length, and mechanism, and
  440.                  skip past these.
  441.   arguments:
  442.     pptr         pointer to buffer pointer
  443.     rxlen        number of bytes after base64 decode
  445.   return value:  0 if error, else token length value
  446.   calls:         none
  447.   globals:       reads outlevel.
  448.  *********************************************************************/
  450. int LenSkip(pptr,rxlen)
  451. unsigned char **pptr;
  452. int rxlen;
  453. {
  454.     int len;
  455.     unsigned char *save;
  456.     save = *pptr;
  457.     if (**pptr != HDR)
  458.     {
  459. if (outlevel > O_SILENT)
  460.     report(stderr, _("Hdr not 60n"));
  461. return(0);
  462.     }
  463.     (*pptr)++;
  464.     if (((**pptr) & 0x80) == 0 )
  465.     {
  466. len = **pptr; (*pptr)++;
  467.     }
  468.     else if ((**pptr) == 0x81)
  469.     {
  470. len = *(*pptr+1); (*pptr) += 2;
  471.     }
  472.     else if ((**pptr) == 0x82)
  473.     {
  474. len = ((*(*pptr+1)) << 8) | *(*pptr+2);
  475. (*pptr) += 3;
  476.     }
  477.     else len = 0;
  478.     if (len==0)
  479.     {
  480. if (outlevel>O_SILENT)
  481.     report(stderr, _("Token length errorn"));
  482.     }
  483.     else if (((*pptr-save)+len) != rxlen)
  484.     {
  485. if (outlevel>O_SILENT)
  486.     report(stderr, _("Token Length %d disagrees with rxlen %dn"),len,rxlen);
  487. len = 0;
  488.     }
  489.     else if (memcmp(*pptr,MECH,11))
  490.     {
  491. if (outlevel > O_SILENT)
  492.     report(stderr, _("Mechanism field incorrectn"));
  493. len = 0;
  494.     }
  495.     else (*pptr) += 11;  /* Skip mechanism field */
  496.     return(len);
  497. }
  499. /*********************************************************************
  500.   function:      DecBase64
  501.   description:   Decode a Base64 string, overwriting the original.
  502.                  Note that result cannot be longer than input.
  504.   arguments:
  505.     bufp         buffer
  507.   return value:  0 if error, else number of bytes in decoded result
  508.   calls:         none
  509.   globals:       reads outlevel.
  510.  *********************************************************************/
  512. static int DecBase64(bufp)
  513. unsigned char *bufp;
  514. {
  515.     unsigned int   new, bits=0, cnt=0, i, part=0;
  516.     unsigned char  ch;
  517.     unsigned char* outp=bufp;
  518.     unsigned char* inp=bufp;
  519.     while((ch=*(inp++)) != 0)
  520.     {
  521. if ((ch != '=') && (ch != ' ') && (ch != 'n') && (ch != 'r'))
  522. {
  523.     if      ((ch>='A') && (ch <= 'Z'))   new = ch - 'A';
  524.     else if ((ch>='a') && (ch <= 'z'))   new = ch - 'a' + 26;
  525.     else if ((ch>='0') && (ch <= '9'))   new = ch - '0' + 52;
  526.     else if ( ch=='+'                )   new = 62;
  527.     else if ( ch=='/'                )   new = 63;
  528.     else {
  529. report(stderr,  _("dec64 error at char %d: %xn"), inp - bufp, ch);
  530. return(0);
  531.     }
  532.     part=((part & 0x3F)*64) + new;
  533.     bits += 6;
  534.     if (bits >= 8)
  535.     {
  536. bits -= 8;
  537. *outp = (part >> bits);
  538. cnt++; outp++;
  539.     }
  540. }
  541.     }
  542.     if (outlevel >= O_MONITOR)
  543.     {
  544. report(stdout, _("Inbound binary data:n"));
  545. for (i=0; i<cnt; i++)
  546. {
  547.     report_build(stdout, "%02X ",bufp[i]);
  548.     if (((i % 16)==15) || (i==(cnt-1)))
  549. report_complete(stdout, "n");
  550. }
  551.     }
  552.     return(cnt);
  553. }
  555. /*********************************************************************
  556.   function:      EncBase64
  557.   description:   Encode into Base64 string, overwriting the original.
  558.                  Note that result CAN be longer than input, the buffer
  559.                  is assumed to be big enough. Result string is
  560.                  terminated with .
  562.   arguments:
  563.     bufp         buffer
  564.     len          number of bytes in buffer (>0)
  566.   return value:  none
  567.   calls:         none
  568.   globals:       reads outlevel;
  569.  *********************************************************************/
  571. static void EncBase64(bufp,len)
  572. unsigned char *bufp;
  573. int  len;
  574. {
  575.     unsigned char* outp;
  576.     unsigned char  c1,c2,c3;
  577.     char x[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  578.     int  i;
  580.     if (outlevel >= O_MONITOR)
  581.     {
  582. report(stdout, _("Outbound data:n"));
  583. for (i=0; i<len; i++)
  584. {
  585.     report_build(stdout, "%02X ",bufp[i]);
  586.     if (((i % 16)==15) || (i==(len-1)))
  587. report_complete(stdout, "n");
  588. }
  589.     }
  590.     outp = bufp + (((len-1)/3)*4);
  591.     *(outp+4) = 0;
  592.     /* So we can do the update in place, start at the far end! */
  593.     for (i=((len-1)/3)*3; i>=0; i-=3)
  594.     {
  595. c1 = bufp[i];
  596. if ((i+1) < len) c2 = bufp[i+1]; else c2=0;
  597. if ((i+2) < len) c3 = bufp[i+2]; else c3=0;
  598. *(outp) = x[c1/4];
  599. *(outp+1) = x[((c1 & 3)*16) + (c2/16)];
  600. if ((i+1) < len) *(outp+2) = x[((c2 & 0x0F)*4) + (c3/64)];
  601. else *(outp+2) = '=';
  602. if ((i+2) < len) *(outp+3) = x[c3 & 0x3F];
  603. else *(outp+3) = '=';
  604. outp -= 4;
  605.     }
  606. }
  608. /*********************************************************************
  609.   function:      ToUnicode
  610.   description:   Convert ASCII (or iso-8859-1) byte string into
  611.                  Unicode. Ensure length isn't too long (STRMAX).
  613.   arguments:
  614.     pptr         pointer to input buffer
  615.     delim        delimiter character (in addition to )
  616.     buf          buffer where Unicode will go
  617.     plen         pointer to length variable (# bytes output)
  618.     conv         1 to convert to lowercase, 0 leaves alone
  620.   return value:  none
  621.   calls:         none
  622.   globals:       reads outlevel;
  623.  *********************************************************************/
  625. static void ToUnicode(pptr,delim,buf,plen,conv)
  626. unsigned char **pptr; /* input string  */
  627. unsigned char delim;
  628. unsigned char *buf;   /* output buffer */
  629. int  *plen;
  630. int conv;
  631. {
  632.     unsigned char *p;
  633.     int i;
  634.     *plen = 0; p=buf;
  635.     while ( ((**pptr)!=delim) && ((**pptr)!=0) && ((*plen)<STRMAX) )
  636.     {
  637. *(p++) = 0;
  638. if (conv)
  639.     *(p++) = tolower(**pptr);
  640. else
  641.     *(p++) = (**pptr);
  642. (*plen) += 2;
  643. (*pptr)++;
  644.     }
  645.     if ( ((**pptr)!=delim) && ((**pptr)!=0) && ((*plen)==STRMAX) )
  646.     {
  647. if (outlevel > O_SILENT)
  648.     report(stderr, _("RPA String too longn"));
  649. *plen = 0;
  650.     }
  651.     if (outlevel >= O_DEBUG)
  652.     {
  653. report(stdout, _("Unicode:n"));
  654. for (i=0; i<(*plen); i++)
  655. {
  656.     report_build(stdout, "%02X ",buf[i]);
  657.     if (((i % 16)==15) || (i==((*plen)-1)))
  658. report_complete(stdout, "n");
  659. }
  660.     }
  661. }
  663. /*********************************************************************
  664.   function:      SetRealmService
  665.   description:   Select a realm from list, and store it.
  667.   arguments:
  668.     bufp         pointer to buffer
  670.   return value:  none
  671.   calls:         none
  672.   globals:       reads outlevel.
  673.                  writes Ns Nsl Nr Nrl
  674.  *********************************************************************/
  676. static int SetRealmService(bufp)
  677. unsigned char* bufp;
  678. {
  679.     /* For the moment we pick the first available realm. It would */
  680.     /* make more sense to verify that the realm which the user    */
  681.     /* has given (as part of id) is in the list, and select it's  */
  682.     /* corresponding service name.                                */
  683.     ToUnicode(&bufp, '@', Ns, &Nsl, 1);  /* Service    */
  684.     bufp++;                              /* Skip the @ */
  685.     ToUnicode(&bufp, ' ', Nr, &Nrl, 1);  /* Realm name */
  686.     if ((Nrl == 0) || (Nsl == 0))
  687. return(PS_RPA);
  688.     return(0);
  689. }
  691. /*********************************************************************
  692.   function:      GenChallenge
  693.   description:   Generate a random User challenge
  695.   arguments:
  696.     buf          pointer to buffer
  697.     len          length in bytes
  699.   return value:  none
  700.   calls:         none
  701.   globals:       reads outlevel.
  702.                  reads /dev/random
  703.  *********************************************************************/
  705. static void GenChallenge(buf,len)
  706. unsigned char *buf;
  707. int  len;
  708. {
  709.     int  i;
  710.     FILE *devrandom;
  712.     devrandom = fopen("/dev/urandom","rb");
  713.     if (devrandom == NULL && outlevel > O_SILENT)
  714.     {
  715. report(stdout, _("RPA Failed open of /dev/urandom. This shouldn'tn"));
  716. report(stdout, _("    prevent you logging in, but means youn"));
  717. report(stdout, _("    cannot be sure you are talking to then"));
  718. report(stdout, _("    service that you think you are (replayn"));
  719. report(stdout, _("    attacks by a dishonest service are possible.)n"));
  720.     }
  722.     for(i=0; i<len; i++)
  723. buf[i] = devrandom ? fgetc(devrandom) : random();
  725.     if (devrandom)
  726. fclose(devrandom); /* should be safe, file mode was "r" */
  728.     if (outlevel >= O_DEBUG)
  729.     {
  730. report(stdout, _("User challenge:n"));
  731. for (i=0; i<len; i++)
  732.   {
  733.   report_build(stdout, "%02X ",buf[i]);
  734.   if (((i % 16)==15) || (i==(len-1)))
  735.     report_complete(stdout, "n");
  736.   }
  737.     }
  738. }
  740. /*********************************************************************
  741.   function:      DigestPassphrase
  742.   description:   Use MD5 to compute digest (Pu) of Passphrase
  743.                  Don't map to lower case. We assume the user is
  744.                  aware of the case requirement of the realm.
  745.                  (Why oh why have options in the spec?!)
  746.   arguments:
  747.     passphrase   buffer containing string,  terminated
  748.     rbuf         buffer into which digest goes
  750.   return value:  0 if ok, else error code
  751.   calls:         md5
  752.   globals:       reads authentication items listed above.
  753.                  writes Pu.
  754.  *********************************************************************/
  756. static int DigestPassphrase(passphrase,rbuf,unicodeit)
  757. unsigned char *passphrase;
  758. unsigned char *rbuf;
  759. int unicodeit;
  760. {
  761.     int   len;
  762.     unsigned char  workarea[STRMAX];
  763.     unsigned char* ptr;
  765.     if (unicodeit)  /* Option in spec. Yuck. */
  766.     {
  767. ptr = passphrase;
  768. ToUnicode(&ptr, '', workarea, &len, 0); /* No case conv here */
  769. if (len == 0)
  770.     return(PS_SYNTAX);
  771. ptr = workarea;
  772.     }
  773.     else
  774.     {
  775. ptr = rbuf;
  776. len = strlen(passphrase);
  777.     }
  778.     md5(ptr,len,rbuf);
  779.     return(0);
  780. }
  782. /*********************************************************************
  783.   function:      CompUserResp
  784.   description:   Use MD5 to compute User Response (Ru) from
  785.                  Pu Z(48) Nu Ns Nr Cu Cs Ts Pu
  787.   arguments:     none
  789.   return value:  none
  790.   calls:         MD5
  791.   globals:       reads authentication items listed above.
  792.                  writes Ru.
  793.  *********************************************************************/
  795. static void CompUserResp()
  796. {
  797.     unsigned char  workarea[Pul+48+STRMAX*5+Tsl+Pul];
  798.     unsigned char* p;
  799.     p = workarea;
  800.     memcpy(p , Pu,  Pul); p += Pul;
  801.     memset(p , '', 48); p += 48;
  802.     memcpy(p , Nu,  Nul); p += Nul;
  803.     memcpy(p , Ns,  Nsl); p += Nsl;
  804.     memcpy(p , Nr,  Nrl); p += Nrl;
  805.     memcpy(p , Cu,  Cul); p += Cul;
  806.     memcpy(p , Cs,  Csl); p += Csl;
  807.     memcpy(p , Ts,  Tsl); p += Tsl;
  808.     memcpy(p , Pu,  Pul); p += Pul;
  809.     md5(workarea,p-workarea,Ru);
  810. }
  812. /*********************************************************************
  813.   function:      CheckUserAuth
  814.   description:   Use MD5 to verify Authentication Response to User (Au)
  815.                  using  Pu Z(48) Ns Nu Nr Kusu Cs Cu Ts Kus Pu
  816.                  Also creates unobscured session key Kus from obscured
  817.                  one Kusu
  819.   arguments:     none
  821.   return value:  0 if ok, PS_RPA if mismatch
  822.   calls:         MD5
  823.   globals:       reads authentication items listed above.
  824.                  writes Ru.
  825.  *********************************************************************/
  827. static int CheckUserAuth()
  828. {
  829.     unsigned char  workarea[Pul+48+STRMAX*7+Tsl+Pul];
  830.     unsigned char* p;
  831.     unsigned char  md5ans[16];
  832.     int i;
  833.     /* Create unobscured Kusu */
  834.     p = workarea;
  835.     memcpy(p , Pu,  Pul); p += Pul;
  836.     memset(p , '', 48); p += 48;
  837.     memcpy(p , Ns,  Nsl); p += Nsl;
  838.     memcpy(p , Nu,  Nul); p += Nul;
  839.     memcpy(p , Nr,  Nrl); p += Nrl;
  840.     memcpy(p , Cs,  Csl); p += Csl;
  841.     memcpy(p , Cu,  Cul); p += Cul;
  842.     memcpy(p , Ts,  Tsl); p += Tsl;
  843.     memcpy(p , Pu,  Pul); p += Pul;
  844.     md5(workarea,p-workarea,md5ans);
  845.     for (i=0; i<16; i++) Kus[i] = Kusu[i] ^ md5ans[i];
  846.     /* Compute Au from our information */
  847.     p = workarea;
  848.     memcpy(p , Pu,  Pul); p += Pul;
  849.     memset(p , '', 48); p += 48;
  850.     memcpy(p , Ns,  Nsl); p += Nsl;
  851.     memcpy(p , Nu,  Nul); p += Nul;
  852.     memcpy(p , Nr,  Nrl); p += Nrl;
  853.     memcpy(p , Kusu,Kusl);p += Kusl;
  854.     memcpy(p , Cs,  Csl); p += Csl;
  855.     memcpy(p , Cu,  Cul); p += Cul;
  856.     memcpy(p , Ts,  Tsl); p += Tsl;
  857.     memcpy(p , Kus, Kusl);p += Kusl;
  858.     memcpy(p , Pu,  Pul); p += Pul;
  859.     md5(workarea,p-workarea,md5ans);
  860.     /* Compare the two */
  861.     for (i=0; i<16; i++)
  862. if (Au[i] != md5ans[i]) return(PS_RPA);
  863.     return(0);
  864. }
  866. /*********************************************************************
  867.   function:      md5
  868.   description:   Apply MD5
  869.   arguments:
  870.     in           input byte stream
  871.     len          length in bytes
  872.     out          128 bit result buffer
  873.   return value:  none
  874.   calls:         MD5 primitives
  875.   globals:       reads outlevel
  876.  *********************************************************************/
  878. static void md5(in,len,out)
  879. unsigned char*    in;
  880. int      len;
  881. unsigned char*    out;
  882. {
  883.     int      i;
  884.     MD5_CTX  md5context;
  886.     if (outlevel >= O_DEBUG)
  887.     {
  888. report(stdout, _("MD5 being applied to data block:n"));
  889. for (i=0; i<len; i++)
  890. {
  891.     report_build(stdout, "%02X ",in[i]);
  892.     if (((i % 16)==15) || (i==(len-1)))
  893. report_complete(stdout, "n");
  894. }
  895.     }
  896.     MD5Init(   &md5context );
  897.     MD5Update( &md5context, in, len );
  898.     MD5Final(  out, &md5context );
  899.     if (outlevel >= O_DEBUG)
  900.     {
  901. report(stdout, _("MD5 result is: n"));
  902. for (i=0; i<16; i++)
  903. {
  904.     report_build(stdout, "%02X ",out[i]);
  905. }
  906. report_complete(stdout, "n");
  907.     }
  908. }
  909. #endif /* POP3_ENABLE && RPA_ENABLE */
  911. /* rpa.c ends here */