v 0. Pasted by KpeHDeJIb as c at 2011-05-17 20:37:09 MSK and set expiration to never.

Paste will expire never. Expiration is locked.

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <errno.h>
  5. #include <syslog.h>
  6. #include <unistd.h>
  7. #include <signal.h>
  8. #include <sys/socket.h>
  9. #include <sys/types.h>
  10. #include <netinet/in.h>
  11. #include <arpa/inet.h>
  12.  
  13. #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
  14. #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
  15. #define H(x, y, z) ((x) ^ (y) ^ (z))
  16. #define I(x, y, z) ((y) ^ ((x) | (~z)))
  17.  
  18. #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
  19.  
  20. #define FF(a, b, c, d, x, s, ac) \
  21.     { \
  22.         (a) += F ((b), (c), (d)) + (x) + (uint32)(ac); \
  23.         (a) = ROTATE_LEFT ((a), (s)); \
  24.         (a) += (b); \
  25.     }
  26.  
  27. #define GG(a, b, c, d, x, s, ac) \
  28.     { \
  29.         (a) += G ((b), (c), (d)) + (x) + (uint32)(ac); \
  30.         (a) = ROTATE_LEFT ((a), (s)); \
  31.         (a) += (b); \
  32.     }
  33.  
  34. #define HH(a, b, c, d, x, s, ac) \
  35.     { \
  36.         (a) += H ((b), (c), (d)) + (x) + (uint32)(ac); \
  37.         (a) = ROTATE_LEFT ((a), (s)); \
  38.         (a) += (b); \
  39.     }
  40.  
  41. #define II(a, b, c, d, x, s, ac) \
  42.     { \
  43.         (a) += I ((b), (c), (d)) + (x) + (uint32)(ac); \
  44.         (a) = ROTATE_LEFT ((a), (s)); \
  45.         (a) += (b); \
  46.     }
  47.  
  48. typedef unsigned char     uint8;
  49. typedef unsigned long int uint32;
  50. typedef long int          int32;
  51.  
  52. typedef struct
  53. {
  54.   uint32 i[2];
  55.   uint32 buf[4];
  56.   uint8  in[64];
  57.   uint8  digest[16];
  58. } MD5_CTX;
  59.  
  60. void MD5Init(MD5_CTX *mdContext);
  61. void MD5Update(MD5_CTX *mdContext, const uint8 *inBuf, uint32 inLen);
  62. void MD5Final(MD5_CTX *mdContext);
  63. void Transform(uint32 *buf, const uint32 *in);
  64.  
  65. static uint8 PADDING[64] =
  66. {
  67.     0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  68.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  69.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  70.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  71.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  72.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  73.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  74.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  75. };
  76.  
  77. #define BUFFER_SIZE 1024
  78.  
  79. #define READ_TIMEOUT  10
  80. #define WRITE_TIMEOUT 10
  81.  
  82. #define RETRY_TIME 20
  83. #define AUTH_TIME  240
  84.  
  85. #define ACTION_DENIED   0
  86. #define ACTION_AUTH     1
  87. #define ACTION_REDIRECT 2
  88.  
  89. #define KAUTHD_NOTICE(...) syslog(LOG_NOTICE, __VA_ARGS__)
  90. #define KAUTHD_ERROR(...)  syslog(LOG_ERR, __VA_ARGS__)
  91.  
  92. static ssize_t kauthd_read(int sd, char *buffer, size_t length);
  93. static ssize_t kauthd_write(int sd, char *buffer, size_t length);
  94.  
  95. static void kauthd_md5_digest(unsigned char digest[16], char level,
  96.     const char *challenge, int clength, const char *ip, const char *password);
  97.  
  98. int main(int argc, char *argv[])
  99. {
  100.     int sd, result, size, run, auth, version, level;
  101.     char action, length, buffer[BUFFER_SIZE], password[33];
  102.     ssize_t readed, written;
  103.     struct sockaddr_in remote, local;
  104.     unsigned char digest[16];
  105.     const char *password;
  106.  
  107.     if (argc < 2)
  108.     {
  109.         fprintf(stderr, "usage: kauthd <password>\n");
  110.         return 1;
  111.     }
  112.  
  113.     openlog("kauthd", LOG_PID, LOG_DAEMON);
  114.  
  115.     strncpy(password, argv[1], 32);
  116.     password[32] = 0;
  117.  
  118.     memset(argv[1], '*', strlen(argv[1]));
  119.  
  120.     size    = sizeof(struct sockaddr_in);
  121.     version = 1;
  122.     level   = 2;
  123.     run     = 1;
  124.     sd      = 0;
  125.  
  126.     memset(buffer, 0, BUFFER_SIZE);
  127.     memset(&remote, 0, size);
  128.  
  129.     remote.sin_family      = AF_INET;
  130.     remote.sin_addr.s_addr = inet_addr("10.0.0.1");
  131.     remote.sin_port        = htons(8899);
  132.  
  133.     signal(SIGPIPE, SIG_IGN);
  134.     signal(SIGHUP,  SIG_IGN);
  135.  
  136.     daemon(0, 0);
  137.  
  138.     while (run)
  139.     {
  140.         if (sd > 0)
  141.         {
  142.             shutdown(sd, SHUT_RDWR);
  143.             close(sd);
  144.  
  145.             sleep(RETRY_TIME);
  146.         }
  147.  
  148.         sd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
  149.         while (sd < 0)
  150.         {
  151.             KAUTHD_ERROR( "Cant create socket (%d)\n", errno);
  152.             continue;
  153.         }
  154.  
  155.         size = sizeof(struct sockaddr_in);
  156.  
  157.         result = connect(sd, (struct sockaddr *)&remote, size);
  158.         if (result < 0 && errno != EISCONN)
  159.         {
  160.             KAUTHD_ERROR("Connection failed (%d)\n", errno);
  161.             continue;
  162.         }
  163.  
  164.         KAUTHD_NOTICE("Connected with protocol version %d\n", version);
  165.  
  166.         getsockname(sd, (struct sockaddr *)&local, &size);
  167.         KAUTHD_NOTICE("Local address is %s\n", inet_ntoa(local.sin_addr));
  168.  
  169.         readed = kauthd_read(sd, buffer, 1);
  170.         if (readed != 1)
  171.         {
  172.             KAUTHD_ERROR("Action reading failed (%d)\n", errno);
  173.             continue;
  174.         }
  175.  
  176.         action = buffer[0];
  177.         switch (action)
  178.         {
  179.             case ACTION_DENIED:
  180.                 KAUTHD_NOTICE("Access denied\n");
  181.                 break;
  182.  
  183.             case ACTION_AUTH:
  184.                 KAUTHD_NOTICE("Continue with authorization\n");
  185.                 break;
  186.  
  187.             case ACTION_REDIRECT:
  188.                 KAUTHD_NOTICE("Redirecting\n");
  189.  
  190.                 readed = kauthd_read(sd, buffer, 1);
  191.                 if (readed != 1)
  192.                 {
  193.                     KAUTHD_ERROR("Cant read server IP length (%d)\n", errno);
  194.                     break;
  195.                 }
  196.  
  197.                 length = buffer[0];
  198.                 if (length < 7 || length > 15)
  199.                 {
  200.                     KAUTHD_ERROR("Bad server IP length\n");
  201.                     break;
  202.                 }
  203.  
  204.                 readed = kauthd_read(sd, buffer, length);
  205.                 if (readed != length)
  206.                 {
  207.                     KAUTHD_ERROR("Cant read server IP (%d)\n", errno);
  208.                     break;
  209.                 }
  210.  
  211.                 buffer[length] = 0;
  212.                 remote.sin_addr.s_addr = inet_addr(buffer);
  213.  
  214.                 KAUTHD_NOTICE("New server address is %s\n", buffer);
  215.                 break;
  216.  
  217.             default:
  218.                 KAUTHD_ERROR("Unknown action\n");
  219.         }
  220.  
  221.         auth = (action == ACTION_AUTH ? 1 : 0);
  222.  
  223.         while (auth)
  224.         {
  225.             readed = kauthd_read(sd, buffer, BUFFER_SIZE);
  226.             if (readed == 0)
  227.             {
  228.                 KAUTHD_ERROR("Cant read challenge (%d)\n", errno);
  229.                 break;
  230.             }
  231.  
  232.             kauthd_md5_digest(digest, level, buffer + 1, buffer[0],
  233.                 inet_ntoa(local.sin_addr), password);
  234.  
  235.             written = kauthd_write(sd, digest, 16);
  236.             if (written != 16)
  237.             {
  238.                 KAUTHD_ERROR("Cant write digest (%d)\n", errno);
  239.                 break;
  240.             }
  241.  
  242.             readed = kauthd_read(sd, buffer, 1);
  243.             if (readed != 1)
  244.             {
  245.                 KAUTHD_ERROR("Cant read access level (%d)\n", errno);
  246.                 break;
  247.             }
  248.  
  249.             if (auth == 1)
  250.                 KAUTHD_NOTICE("Access granted with level %d\n", buffer[0]);
  251.  
  252.             sleep(AUTH_TIME);
  253.             auth = 2;
  254.         }
  255.     }
  256.  
  257.     shutdown(sd, SHUT_RDWR);
  258.     close(sd);
  259.  
  260.     closelog();
  261.  
  262.     return 0;
  263. }
  264.  
  265. static ssize_t kauthd_read(int sd, char *buffer, size_t length)
  266. {
  267.     fd_set fds;
  268.     struct timeval tv;
  269.  
  270.     FD_ZERO(&fds);
  271.     FD_SET(sd, &fds);
  272.  
  273.     tv.tv_sec  = READ_TIMEOUT;
  274.     tv.tv_usec = 0;
  275.  
  276.     if (select(sd + 1, &fds, NULL, NULL, &tv) != 1)
  277.     {
  278.         KAUTHD_ERROR("Cant select socket for reading (%d)\n", errno);
  279.         return 0;
  280.     }
  281.  
  282.     return read(sd, buffer, length);
  283. }
  284.  
  285. static ssize_t kauthd_write(int sd, char *buffer, size_t length)
  286. {
  287.     fd_set fds;
  288.     struct timeval tv;
  289.  
  290.     FD_ZERO(&fds);
  291.     FD_SET(sd, &fds);
  292.  
  293.     tv.tv_sec  = WRITE_TIMEOUT;
  294.     tv.tv_usec = 0;
  295.  
  296.     if (select(sd + 1, NULL, &fds, NULL, &tv) != 1)
  297.     {
  298.         KAUTHD_ERROR("Cant select socket for writing (%d)\n", errno);
  299.         return 0;
  300.     }
  301.  
  302.     return write(sd, buffer, length);
  303. }
  304.  
  305. static void kauthd_md5_digest(unsigned char digest[16], char level,
  306.     const char *challenge, int clength, const char *ip, const char *password)
  307. {
  308.     MD5_CTX ctx;
  309.  
  310.     level += '0';
  311.  
  312.     MD5Init(&ctx);
  313.     MD5Update(&ctx, challenge, clength);
  314.     MD5Update(&ctx, ip, strlen(ip));
  315.     MD5Update(&ctx, &level, 1);
  316.     MD5Update(&ctx, password, strlen(password));
  317.     MD5Final(&ctx);
  318.  
  319.     memcpy(digest, ctx.digest, 16);
  320. }
  321.  
  322. void MD5Init(MD5_CTX *mdContext)
  323. {
  324.     mdContext->i[0] = mdContext->i[1] = (uint32)0;
  325.  
  326.     mdContext->buf[0] = (uint32)0x67452301;
  327.     mdContext->buf[1] = (uint32)0xEFCDAB89;
  328.     mdContext->buf[2] = (uint32)0x98BADCFE;
  329.     mdContext->buf[3] = (uint32)0x10325476;
  330. }
  331.  
  332. void MD5Update(MD5_CTX *mdContext, const uint8 *inBuf, uint32 inLen)
  333. {
  334.     uint32 in[16];
  335.     int32  mdi;
  336.     uint32 i, ii;
  337.  
  338.     mdi = (int32)((mdContext->i[0] >> 3) & 0x3F);
  339.  
  340.     if ((mdContext->i[0] + ((uint32)inLen << 3)) < mdContext->i[0])
  341.         mdContext->i[1]++;
  342.  
  343.     mdContext->i[0] += ((uint32)inLen << 3);
  344.     mdContext->i[1] += ((uint32)inLen >> 29);
  345.  
  346.     while (inLen--)
  347.     {
  348.         mdContext->in[mdi++] = *inBuf++;
  349.  
  350.         if (mdi == 0x40)
  351.         {
  352.             for (i = 0, ii = 0; i < 16; i++, ii += 4)
  353.             {
  354.                 in[i] = (((uint32)mdContext->in[ii+3]) << 24)
  355.                       | (((uint32)mdContext->in[ii+2]) << 16)
  356.                       | (((uint32)mdContext->in[ii+1]) << 8)
  357.                       | ((uint32)mdContext->in[ii]);
  358.             }
  359.  
  360.             Transform(mdContext->buf, in);
  361.             mdi = 0;
  362.         }
  363.     }
  364. }
  365.  
  366. void MD5Final(MD5_CTX *mdContext)
  367. {
  368.     uint32 in[16];
  369.     int32  mdi;
  370.     uint32 i, ii;
  371.     uint32 padLen;
  372.  
  373.     in[14] = mdContext->i[0];
  374.     in[15] = mdContext->i[1];
  375.  
  376.     mdi = (int32)((mdContext->i[0] >> 3) & 0x3F);
  377.  
  378.     padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
  379.     MD5Update (mdContext, PADDING, padLen);
  380.  
  381.     for (i = 0, ii = 0; i < 14; i++, ii += 4)
  382.     {
  383.         in[i] = (((uint32)mdContext->in[ii+3]) << 24)
  384.               | (((uint32)mdContext->in[ii+2]) << 16)
  385.               | (((uint32)mdContext->in[ii+1]) << 8)
  386.               | ((uint32)mdContext->in[ii]);
  387.     }
  388.  
  389.     Transform (mdContext->buf, in);
  390.  
  391.     for (i = 0, ii = 0; i < 4; i++, ii += 4)
  392.     {
  393.         mdContext->digest[ii]   = (uint8)(mdContext->buf[i] & 0xFF);
  394.         mdContext->digest[ii+1] = (uint8)((mdContext->buf[i] >> 8) & 0xFF);
  395.         mdContext->digest[ii+2] = (uint8)((mdContext->buf[i] >> 16) & 0xFF);
  396.         mdContext->digest[ii+3] = (uint8)((mdContext->buf[i] >> 24) & 0xFF);
  397.     }
  398. }
  399.  
  400. void Transform(uint32 *buf, const uint32 *in)
  401. {
  402.     uint32 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
  403.  
  404. #define S11 7
  405. #define S12 12
  406. #define S13 17
  407. #define S14 22
  408.     FF ( a, b, c, d, in[ 0], S11, 3614090360U); /* 1 */
  409.     FF ( d, a, b, c, in[ 1], S12, 3905402710U); /* 2 */
  410.     FF ( c, d, a, b, in[ 2], S13,  606105819U); /* 3 */
  411.     FF ( b, c, d, a, in[ 3], S14, 3250441966U); /* 4 */
  412.     FF ( a, b, c, d, in[ 4], S11, 4118548399U); /* 5 */
  413.     FF ( d, a, b, c, in[ 5], S12, 1200080426U); /* 6 */
  414.     FF ( c, d, a, b, in[ 6], S13, 2821735955U); /* 7 */
  415.     FF ( b, c, d, a, in[ 7], S14, 4249261313U); /* 8 */
  416.     FF ( a, b, c, d, in[ 8], S11, 1770035416U); /* 9 */
  417.     FF ( d, a, b, c, in[ 9], S12, 2336552879U); /* 10 */
  418.     FF ( c, d, a, b, in[10], S13, 4294925233U); /* 11 */
  419.     FF ( b, c, d, a, in[11], S14, 2304563134U); /* 12 */
  420.     FF ( a, b, c, d, in[12], S11, 1804603682U); /* 13 */
  421.     FF ( d, a, b, c, in[13], S12, 4254626195U); /* 14 */
  422.     FF ( c, d, a, b, in[14], S13, 2792965006U); /* 15 */
  423.     FF ( b, c, d, a, in[15], S14, 1236535329U); /* 16 */
  424.  
  425. #define S21 5
  426. #define S22 9
  427. #define S23 14
  428. #define S24 20
  429.     GG ( a, b, c, d, in[ 1], S21, 4129170786U); /* 17 */
  430.     GG ( d, a, b, c, in[ 6], S22, 3225465664U); /* 18 */
  431.     GG ( c, d, a, b, in[11], S23,  643717713U); /* 19 */
  432.     GG ( b, c, d, a, in[ 0], S24, 3921069994U); /* 20 */
  433.     GG ( a, b, c, d, in[ 5], S21, 3593408605U); /* 21 */
  434.     GG ( d, a, b, c, in[10], S22,   38016083U); /* 22 */
  435.     GG ( c, d, a, b, in[15], S23, 3634488961U); /* 23 */
  436.     GG ( b, c, d, a, in[ 4], S24, 3889429448U); /* 24 */
  437.     GG ( a, b, c, d, in[ 9], S21,  568446438U); /* 25 */
  438.     GG ( d, a, b, c, in[14], S22, 3275163606U); /* 26 */
  439.     GG ( c, d, a, b, in[ 3], S23, 4107603335U); /* 27 */
  440.     GG ( b, c, d, a, in[ 8], S24, 1163531501U); /* 28 */
  441.     GG ( a, b, c, d, in[13], S21, 2850285829U); /* 29 */
  442.     GG ( d, a, b, c, in[ 2], S22, 4243563512U); /* 30 */
  443.     GG ( c, d, a, b, in[ 7], S23, 1735328473U); /* 31 */
  444.     GG ( b, c, d, a, in[12], S24, 2368359562U); /* 32 */
  445.  
  446. #define S31 4
  447. #define S32 11
  448. #define S33 16
  449. #define S34 23
  450.     HH ( a, b, c, d, in[ 5], S31, 4294588738U); /* 33 */
  451.     HH ( d, a, b, c, in[ 8], S32, 2272392833U); /* 34 */
  452.     HH ( c, d, a, b, in[11], S33, 1839030562U); /* 35 */
  453.     HH ( b, c, d, a, in[14], S34, 4259657740U); /* 36 */
  454.     HH ( a, b, c, d, in[ 1], S31, 2763975236U); /* 37 */
  455.     HH ( d, a, b, c, in[ 4], S32, 1272893353U); /* 38 */
  456.     HH ( c, d, a, b, in[ 7], S33, 4139469664U); /* 39 */
  457.     HH ( b, c, d, a, in[10], S34, 3200236656U); /* 40 */
  458.     HH ( a, b, c, d, in[13], S31,  681279174U); /* 41 */
  459.     HH ( d, a, b, c, in[ 0], S32, 3936430074U); /* 42 */
  460.     HH ( c, d, a, b, in[ 3], S33, 3572445317U); /* 43 */
  461.     HH ( b, c, d, a, in[ 6], S34,   76029189U); /* 44 */
  462.     HH ( a, b, c, d, in[ 9], S31, 3654602809U); /* 45 */
  463.     HH ( d, a, b, c, in[12], S32, 3873151461U); /* 46 */
  464.     HH ( c, d, a, b, in[15], S33,  530742520U); /* 47 */
  465.     HH ( b, c, d, a, in[ 2], S34, 3299628645U); /* 48 */
  466.  
  467. #define S41 6
  468. #define S42 10
  469. #define S43 15
  470. #define S44 21
  471.     II ( a, b, c, d, in[ 0], S41, 4096336452U); /* 49 */
  472.     II ( d, a, b, c, in[ 7], S42, 1126891415U); /* 50 */
  473.     II ( c, d, a, b, in[14], S43, 2878612391U); /* 51 */
  474.     II ( b, c, d, a, in[ 5], S44, 4237533241U); /* 52 */
  475.     II ( a, b, c, d, in[12], S41, 1700485571U); /* 53 */
  476.     II ( d, a, b, c, in[ 3], S42, 2399980690U); /* 54 */
  477.     II ( c, d, a, b, in[10], S43, 4293915773U); /* 55 */
  478.     II ( b, c, d, a, in[ 1], S44, 2240044497U); /* 56 */
  479.     II ( a, b, c, d, in[ 8], S41, 1873313359U); /* 57 */
  480.     II ( d, a, b, c, in[15], S42, 4264355552U); /* 58 */
  481.     II ( c, d, a, b, in[ 6], S43, 2734768916U); /* 59 */
  482.     II ( b, c, d, a, in[13], S44, 1309151649U); /* 60 */
  483.     II ( a, b, c, d, in[ 4], S41, 4149444226U); /* 61 */
  484.     II ( d, a, b, c, in[11], S42, 3174756917U); /* 62 */
  485.     II ( c, d, a, b, in[ 2], S43,  718787259U); /* 63 */
  486.     II ( b, c, d, a, in[ 9], S44, 3951481745U); /* 64 */
  487.  
  488.     buf[0] += a;
  489.     buf[1] += b;
  490.     buf[2] += c;
  491.     buf[3] += d;
  492. }


Editing is locked.