/** * The QQ2003C protocol plugin * * for gaim * * Copyright (C) 2004 Puzzlebird * * This program 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. * * This program 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA * * * OICQ encryption algorithm * Convert from ASM code provided by PerlOICQ *  * Puzzlebird, Nov-Dec 2002  *//*****************************************************************************//*Notes: (OICQ uses 0x10 iterations, and modified something...)IN : 64  bits of data in v[0] - v[1].OUT: 64  bits of data in w[0] - w[1].KEY: 128 bits of key  in k[0] - k[3].delta is chosen to be the real part of the golden ratio: Sqrt(5/4) - 1/2 ~ 0.618034 multiplied by 2^32. 0x61C88647 is what we can track on the ASM codes.!!*/#ifndef _WIN32#include <arpa/inet.h>#else#include "win32dep.h"#endif#include <string.h>#include "crypt.h"void qq_encipher (    unsigned long *const        v,    const unsigned long *const  k,    unsigned long *const        w) ;void qq_decipher(    unsigned long *const        v,    const unsigned long *const  k,    unsigned long *const        w);void qq_encrypt (      unsigned char*  instr,    int             instrlen,    unsigned char*  key,    unsigned char*  outstr,    int*            outstrlen_prt);	int qq_decrypt (    unsigned char*  instr,    int             instrlen,    unsigned char*  key,    unsigned char*  outstr,    int*            outstrlen_ptr);							/*****************************************************************************/void qq_encipher (    unsigned long *const        v,    const unsigned long *const  k,    unsigned long *const        w) {  register unsigned long     y     = ntohl(v[0]),    z     = ntohl(v[1]),		a     = ntohl(k[0]),    b     = ntohl(k[1]),    c     = ntohl(k[2]),    d     = ntohl(k[3]),    n     = 0x10,    sum   = 0,    delta = 0x9E3779B9; /*  0x9E3779B9 - 0x100000000 = -0x61C88647 */  while (n-- > 0) {    sum += delta;    y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);    z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);  }  w[0] = htonl(y); w[1] = htonl(z);}/*****************************************************************************/void qq_decipher(    unsigned long *const        v,    const unsigned long *const  k,    unsigned long *const        w){  register unsigned long    y     = ntohl(v[0]),    z     = ntohl(v[1]),    a     = ntohl(k[0]),    b     = ntohl(k[1]),    c     = ntohl(k[2]),		d     = ntohl(k[3]),    n     = 0x10,    sum   = 0xE3779B90, 	/* why this ? must be related with n value*/	delta = 0x9E3779B9;  /* sum = delta<<5, in general sum = delta * n */  while (n-- > 0) {    z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);    y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);    sum -= delta;  }     w[0] = htonl(y); w[1] = htonl(z);}/******************************************************************** * encrypt part *******************************************************************/void qq_encrypt (      unsigned char*  instr,    int             instrlen,    unsigned char*  key,    unsigned char*  outstr,    int*            outstrlen_prt){  unsigned char     plain[8],         /* plain text buffer*/    plain_pre_8[8],   /* plain text buffer, previous 8 bytes*/    * crypted,        /* crypted text*/    * crypted_pre_8,  /* crypted test, previous 8 bytes*/    * inp;            /* current position in instr*/  int     pos_in_byte = 1,  /* loop in the byte */    is_header=1,      /* header is one byte*/    count=0,          /* number of bytes being crypted*/    padding = 0;      /* number of padding stuff*/  int rand(void);  void encrypt_every_8_byte (void);    //  int rand(void) {    /* it can be the real random seed function*///    return 0xdead; }  /* override with number, convenient for debug*/    /*** we encrypt every eight byte ***/  void encrypt_every_8_byte (void) {    for(pos_in_byte=0; pos_in_byte<8; pos_in_byte++) {      if(is_header) { plain[pos_in_byte] ^= plain_pre_8[pos_in_byte]; }      else { plain[pos_in_byte] ^= crypted_pre_8[pos_in_byte]; }    } /* prepare plain text*/    qq_encipher( (unsigned long *) plain,       		       (unsigned long *) key,          		     (unsigned long *) crypted);   /* encrypt it*/        for(pos_in_byte=0; pos_in_byte<8; pos_in_byte++) {      crypted[pos_in_byte] ^= plain_pre_8[pos_in_byte];     }     memcpy(plain_pre_8, plain, 8);     /* prepare next*/        crypted_pre_8   =   crypted;       /* store position of previous 8 byte*/    crypted         +=  8;             /* prepare next output*/    count           +=  8;             /* outstrlen increase by 8*/    pos_in_byte     =   0;             /* back to start*/    is_header       =   0;             /* and exit header*/  }/* encrypt_every_8_byte*/   pos_in_byte = (instrlen + 0x0a) % 8; /* header padding decided by instrlen*/  if (pos_in_byte) {     pos_in_byte = 8 - pos_in_byte;   }  plain[0] = (rand() & 0xf8) | pos_in_byte;    memset(plain+1, rand()&0xff, pos_in_byte++);  memset(plain_pre_8, 0x00, sizeof(plain_pre_8));  crypted = crypted_pre_8 = outstr;    padding = 1; /* pad some stuff in header*/  while (padding <= 2) { /* at most two byte */    if(pos_in_byte < 8) { plain[pos_in_byte++] = rand() & 0xff; padding ++; }     if(pos_in_byte == 8){ encrypt_every_8_byte(); }   }    inp = instr;  while (instrlen > 0) {    if (pos_in_byte < 8) { plain[pos_in_byte++] = *(inp++); instrlen --; }    if (pos_in_byte == 8){ encrypt_every_8_byte(); }  }  padding = 1; /* pad some stuff in tailer*/  while (padding <= 7) { /* at most sever byte*/    if (pos_in_byte < 8) { plain[pos_in_byte++] = 0x00; padding ++; }    if (pos_in_byte == 8){ encrypt_every_8_byte(); }  }     *outstrlen_prt = count;}/* qq_encrypt*//********************************************************************  * [decrypt part] * return 0 if failed, otherwise return 1 ********************************************************************/int qq_decrypt (    unsigned char*  instr,    int             instrlen,    unsigned char*  key,    unsigned char*  outstr,    int*            outstrlen_ptr){  unsigned char     decrypted[8], m[8],    * crypt_buff,     * crypt_buff_pre_8,     * outp;  int     count,     context_start,     pos_in_byte,     padding;  int decrypt_every_8_byte (void);  int decrypt_every_8_byte (void) {    for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte ++ ) {        if (context_start + pos_in_byte >= instrlen) return 1;        decrypted[pos_in_byte] ^= crypt_buff[pos_in_byte];    }    qq_decipher( (unsigned long *) decrypted,        	  	     (unsigned long *) key,         	  	   (unsigned long *) decrypted);        context_start +=  8;    crypt_buff    +=  8;    pos_in_byte   =   0;    return 1;  }/* decrypt_every_8_byte*/    /* at least 16 bytes and %8 == 0*/  if ((instrlen % 8) || (instrlen < 16)) return 0;   /* get information from header*/  qq_decipher( (unsigned long *) instr,             (unsigned long *) key,             (unsigned long *) decrypted);  pos_in_byte = decrypted[0] & 0x7;  count = instrlen - pos_in_byte - 10; /* this is the plaintext length*/  /* return if outstr buffer is not large enought or error plaintext length*/  if (*outstrlen_ptr < count || count < 0) return 0;    memset(m, 0, 8);  crypt_buff_pre_8 = m;  *outstrlen_ptr = count;   /* everything is ok! set return string length*/  crypt_buff = instr + 8;   /* address of real data start */  context_start = 8;        /* context is at the second 8 byte*/  pos_in_byte ++;           /* start of paddng stuffv*/    padding = 1;              /* at least one in header*/  while (padding <= 2) {    /* there are 2 byte padding stuff in header*/    if (pos_in_byte < 8) {  /* bypass the padding stuff, none sense data*/      pos_in_byte ++; padding ++;    }    if (pos_in_byte == 8) {      crypt_buff_pre_8 = instr;      if (! decrypt_every_8_byte()) return 0;     }  }/* while*/  outp = outstr;  while(count !=0) {    if (pos_in_byte < 8) {      *outp = crypt_buff_pre_8[pos_in_byte] ^ decrypted[pos_in_byte];      outp ++;      count --;      pos_in_byte ++;    }    if (pos_in_byte == 8) {      crypt_buff_pre_8 = crypt_buff - 8;      if (! decrypt_every_8_byte()) return 0;    }  }/* while*/    for (padding = 1; padding < 8; padding ++) {    if (pos_in_byte < 8) {      if (crypt_buff_pre_8[pos_in_byte] ^ decrypted[pos_in_byte]) return 0;      pos_in_byte ++;     }    if (pos_in_byte == 8 ) {      crypt_buff_pre_8 = crypt_buff;      if (! decrypt_every_8_byte()) return 0;     }  }/* for*/  return 1;}/* qq_decrypt*//*****************************************************************************//* This is the Public Function *//* return 1 is succeed, otherwise return 0*/int crypt (    unsigned char   flag,    unsigned char*  instr,    int             instrlen,    unsigned char*  key,    unsigned char*  outstr,    int*            outstrlen_ptr){  if (flag == DECRYPT)    return qq_decrypt(instr, instrlen, key, outstr, outstrlen_ptr);  else if (flag == ENCRYPT)    qq_encrypt(instr, instrlen, key, outstr, outstrlen_ptr);  return 1; /* flag must be DECRYPT or ENCRYPT*/}/* qq_crypt*//*****************************************************************************//* END OF FILE*/