Mercurial > pidgin
view libpurple/ciphers/des.c @ 32443:16925948a003
Use accessor functions where available.
author | Elliott Sales de Andrade <qulogic@pidgin.im> |
---|---|
date | Wed, 04 Jan 2012 02:34:24 +0000 |
parents | ca94413ccd0e |
children |
line wrap: on
line source
/* * purple * * Purple is the legal property of its developers, whose names are too numerous * to list here. Please refer to the COPYRIGHT file distributed with this * source distribution. * * Original des taken from gpg * * des.c - DES and Triple-DES encryption/decryption Algorithm * Copyright (C) 1998 Free Software Foundation, Inc. * * Please see below for more legal information! * * According to the definition of DES in FIPS PUB 46-2 from December 1993. * For a description of triple encryption, see: * Bruce Schneier: Applied Cryptography. Second Edition. * John Wiley & Sons, 1996. ISBN 0-471-12845-7. Pages 358 ff. * * This file is part of GnuPG. * * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */ #include <cipher.h> /****************************************************************************** * DES *****************************************************************************/ typedef struct _des_ctx { guint32 encrypt_subkeys[32]; guint32 decrypt_subkeys[32]; } des_ctx[1]; /* * The s-box values are permuted according to the 'primitive function P' */ static const guint32 sbox1[64] = { 0x00808200, 0x00000000, 0x00008000, 0x00808202, 0x00808002, 0x00008202, 0x00000002, 0x00008000, 0x00000200, 0x00808200, 0x00808202, 0x00000200, 0x00800202, 0x00808002, 0x00800000, 0x00000002, 0x00000202, 0x00800200, 0x00800200, 0x00008200, 0x00008200, 0x00808000, 0x00808000, 0x00800202, 0x00008002, 0x00800002, 0x00800002, 0x00008002, 0x00000000, 0x00000202, 0x00008202, 0x00800000, 0x00008000, 0x00808202, 0x00000002, 0x00808000, 0x00808200, 0x00800000, 0x00800000, 0x00000200, 0x00808002, 0x00008000, 0x00008200, 0x00800002, 0x00000200, 0x00000002, 0x00800202, 0x00008202, 0x00808202, 0x00008002, 0x00808000, 0x00800202, 0x00800002, 0x00000202, 0x00008202, 0x00808200, 0x00000202, 0x00800200, 0x00800200, 0x00000000, 0x00008002, 0x00008200, 0x00000000, 0x00808002 }; static const guint32 sbox2[64] = { 0x40084010, 0x40004000, 0x00004000, 0x00084010, 0x00080000, 0x00000010, 0x40080010, 0x40004010, 0x40000010, 0x40084010, 0x40084000, 0x40000000, 0x40004000, 0x00080000, 0x00000010, 0x40080010, 0x00084000, 0x00080010, 0x40004010, 0x00000000, 0x40000000, 0x00004000, 0x00084010, 0x40080000, 0x00080010, 0x40000010, 0x00000000, 0x00084000, 0x00004010, 0x40084000, 0x40080000, 0x00004010, 0x00000000, 0x00084010, 0x40080010, 0x00080000, 0x40004010, 0x40080000, 0x40084000, 0x00004000, 0x40080000, 0x40004000, 0x00000010, 0x40084010, 0x00084010, 0x00000010, 0x00004000, 0x40000000, 0x00004010, 0x40084000, 0x00080000, 0x40000010, 0x00080010, 0x40004010, 0x40000010, 0x00080010, 0x00084000, 0x00000000, 0x40004000, 0x00004010, 0x40000000, 0x40080010, 0x40084010, 0x00084000 }; static const guint32 sbox3[64] = { 0x00000104, 0x04010100, 0x00000000, 0x04010004, 0x04000100, 0x00000000, 0x00010104, 0x04000100, 0x00010004, 0x04000004, 0x04000004, 0x00010000, 0x04010104, 0x00010004, 0x04010000, 0x00000104, 0x04000000, 0x00000004, 0x04010100, 0x00000100, 0x00010100, 0x04010000, 0x04010004, 0x00010104, 0x04000104, 0x00010100, 0x00010000, 0x04000104, 0x00000004, 0x04010104, 0x00000100, 0x04000000, 0x04010100, 0x04000000, 0x00010004, 0x00000104, 0x00010000, 0x04010100, 0x04000100, 0x00000000, 0x00000100, 0x00010004, 0x04010104, 0x04000100, 0x04000004, 0x00000100, 0x00000000, 0x04010004, 0x04000104, 0x00010000, 0x04000000, 0x04010104, 0x00000004, 0x00010104, 0x00010100, 0x04000004, 0x04010000, 0x04000104, 0x00000104, 0x04010000, 0x00010104, 0x00000004, 0x04010004, 0x00010100 }; static const guint32 sbox4[64] = { 0x80401000, 0x80001040, 0x80001040, 0x00000040, 0x00401040, 0x80400040, 0x80400000, 0x80001000, 0x00000000, 0x00401000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00400040, 0x80400000, 0x80000000, 0x00001000, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x80001000, 0x00001040, 0x80400040, 0x80000000, 0x00001040, 0x00400040, 0x00001000, 0x00401040, 0x80401040, 0x80000040, 0x00400040, 0x80400000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00000000, 0x00401000, 0x00001040, 0x00400040, 0x80400040, 0x80000000, 0x80401000, 0x80001040, 0x80001040, 0x00000040, 0x80401040, 0x80000040, 0x80000000, 0x00001000, 0x80400000, 0x80001000, 0x00401040, 0x80400040, 0x80001000, 0x00001040, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x00001000, 0x00401040 }; static const guint32 sbox5[64] = { 0x00000080, 0x01040080, 0x01040000, 0x21000080, 0x00040000, 0x00000080, 0x20000000, 0x01040000, 0x20040080, 0x00040000, 0x01000080, 0x20040080, 0x21000080, 0x21040000, 0x00040080, 0x20000000, 0x01000000, 0x20040000, 0x20040000, 0x00000000, 0x20000080, 0x21040080, 0x21040080, 0x01000080, 0x21040000, 0x20000080, 0x00000000, 0x21000000, 0x01040080, 0x01000000, 0x21000000, 0x00040080, 0x00040000, 0x21000080, 0x00000080, 0x01000000, 0x20000000, 0x01040000, 0x21000080, 0x20040080, 0x01000080, 0x20000000, 0x21040000, 0x01040080, 0x20040080, 0x00000080, 0x01000000, 0x21040000, 0x21040080, 0x00040080, 0x21000000, 0x21040080, 0x01040000, 0x00000000, 0x20040000, 0x21000000, 0x00040080, 0x01000080, 0x20000080, 0x00040000, 0x00000000, 0x20040000, 0x01040080, 0x20000080 }; static const guint32 sbox6[64] = { 0x10000008, 0x10200000, 0x00002000, 0x10202008, 0x10200000, 0x00000008, 0x10202008, 0x00200000, 0x10002000, 0x00202008, 0x00200000, 0x10000008, 0x00200008, 0x10002000, 0x10000000, 0x00002008, 0x00000000, 0x00200008, 0x10002008, 0x00002000, 0x00202000, 0x10002008, 0x00000008, 0x10200008, 0x10200008, 0x00000000, 0x00202008, 0x10202000, 0x00002008, 0x00202000, 0x10202000, 0x10000000, 0x10002000, 0x00000008, 0x10200008, 0x00202000, 0x10202008, 0x00200000, 0x00002008, 0x10000008, 0x00200000, 0x10002000, 0x10000000, 0x00002008, 0x10000008, 0x10202008, 0x00202000, 0x10200000, 0x00202008, 0x10202000, 0x00000000, 0x10200008, 0x00000008, 0x00002000, 0x10200000, 0x00202008, 0x00002000, 0x00200008, 0x10002008, 0x00000000, 0x10202000, 0x10000000, 0x00200008, 0x10002008 }; static const guint32 sbox7[64] = { 0x00100000, 0x02100001, 0x02000401, 0x00000000, 0x00000400, 0x02000401, 0x00100401, 0x02100400, 0x02100401, 0x00100000, 0x00000000, 0x02000001, 0x00000001, 0x02000000, 0x02100001, 0x00000401, 0x02000400, 0x00100401, 0x00100001, 0x02000400, 0x02000001, 0x02100000, 0x02100400, 0x00100001, 0x02100000, 0x00000400, 0x00000401, 0x02100401, 0x00100400, 0x00000001, 0x02000000, 0x00100400, 0x02000000, 0x00100400, 0x00100000, 0x02000401, 0x02000401, 0x02100001, 0x02100001, 0x00000001, 0x00100001, 0x02000000, 0x02000400, 0x00100000, 0x02100400, 0x00000401, 0x00100401, 0x02100400, 0x00000401, 0x02000001, 0x02100401, 0x02100000, 0x00100400, 0x00000000, 0x00000001, 0x02100401, 0x00000000, 0x00100401, 0x02100000, 0x00000400, 0x02000001, 0x02000400, 0x00000400, 0x00100001 }; static const guint32 sbox8[64] = { 0x08000820, 0x00000800, 0x00020000, 0x08020820, 0x08000000, 0x08000820, 0x00000020, 0x08000000, 0x00020020, 0x08020000, 0x08020820, 0x00020800, 0x08020800, 0x00020820, 0x00000800, 0x00000020, 0x08020000, 0x08000020, 0x08000800, 0x00000820, 0x00020800, 0x00020020, 0x08020020, 0x08020800, 0x00000820, 0x00000000, 0x00000000, 0x08020020, 0x08000020, 0x08000800, 0x00020820, 0x00020000, 0x00020820, 0x00020000, 0x08020800, 0x00000800, 0x00000020, 0x08020020, 0x00000800, 0x00020820, 0x08000800, 0x00000020, 0x08000020, 0x08020000, 0x08020020, 0x08000000, 0x00020000, 0x08000820, 0x00000000, 0x08020820, 0x00020020, 0x08000020, 0x08020000, 0x08000800, 0x08000820, 0x00000000, 0x08020820, 0x00020800, 0x00020800, 0x00000820, 0x00000820, 0x00020020, 0x08000000, 0x08020800 }; /* * * These two tables are part of the 'permuted choice 1' function. * * In this implementation several speed improvements are done. * */ static const guint32 leftkey_swap[16] = { 0x00000000, 0x00000001, 0x00000100, 0x00000101, 0x00010000, 0x00010001, 0x00010100, 0x00010101, 0x01000000, 0x01000001, 0x01000100, 0x01000101, 0x01010000, 0x01010001, 0x01010100, 0x01010101 }; static const guint32 rightkey_swap[16] = { 0x00000000, 0x01000000, 0x00010000, 0x01010000, 0x00000100, 0x01000100, 0x00010100, 0x01010100, 0x00000001, 0x01000001, 0x00010001, 0x01010001, 0x00000101, 0x01000101, 0x00010101, 0x01010101, }; /* * Numbers of left shifts per round for encryption subkey schedule * To calculate the decryption key scheduling we just reverse the * ordering of the subkeys so we can omit the table for decryption * subkey schedule. */ static const guint8 encrypt_rotate_tab[16] = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 }; /* * Macro to swap bits across two words **/ #define DO_PERMUTATION(a, temp, b, offset, mask) \ temp = ((a>>offset) ^ b) & mask; \ b ^= temp; \ a ^= temp<<offset; /* * This performs the 'initial permutation' for the data to be encrypted or decrypted **/ #define INITIAL_PERMUTATION(left, temp, right) \ DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f) \ DO_PERMUTATION(left, temp, right, 16, 0x0000ffff) \ DO_PERMUTATION(right, temp, left, 2, 0x33333333) \ DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff) \ DO_PERMUTATION(left, temp, right, 1, 0x55555555) /* * The 'inverse initial permutation' **/ #define FINAL_PERMUTATION(left, temp, right) \ DO_PERMUTATION(left, temp, right, 1, 0x55555555) \ DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff) \ DO_PERMUTATION(right, temp, left, 2, 0x33333333) \ DO_PERMUTATION(left, temp, right, 16, 0x0000ffff) \ DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f) /* * A full DES round including 'expansion function', 'sbox substitution' * and 'primitive function P' but without swapping the left and right word. **/ #define DES_ROUND(from, to, work, subkey) \ work = ((from<<1) | (from>>31)) ^ *subkey++; \ to ^= sbox8[ work & 0x3f ]; \ to ^= sbox6[ (work>>8) & 0x3f ]; \ to ^= sbox4[ (work>>16) & 0x3f ]; \ to ^= sbox2[ (work>>24) & 0x3f ]; \ work = ((from>>3) | (from<<29)) ^ *subkey++; \ to ^= sbox7[ work & 0x3f ]; \ to ^= sbox5[ (work>>8) & 0x3f ]; \ to ^= sbox3[ (work>>16) & 0x3f ]; \ to ^= sbox1[ (work>>24) & 0x3f ]; /* * Macros to convert 8 bytes from/to 32bit words **/ #define READ_64BIT_DATA(data, left, right) \ left = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3]; \ right = (data[4] << 24) | (data[5] << 16) | (data[6] << 8) | data[7]; #define WRITE_64BIT_DATA(data, left, right) \ data[0] = (left >> 24) &0xff; data[1] = (left >> 16) &0xff; \ data[2] = (left >> 8) &0xff; data[3] = left &0xff; \ data[4] = (right >> 24) &0xff; data[5] = (right >> 16) &0xff; \ data[6] = (right >> 8) &0xff; data[7] = right &0xff; /* * des_key_schedule(): Calculate 16 subkeys pairs (even/odd) for * 16 encryption rounds. * To calculate subkeys for decryption the caller * have to reorder the generated subkeys. * * rawkey: 8 Bytes of key data * subkey: Array of at least 32 guint32s. Will be filled * with calculated subkeys. * **/ static void des_key_schedule (const guint8 * rawkey, guint32 * subkey) { guint32 left, right, work; int round; READ_64BIT_DATA (rawkey, left, right) DO_PERMUTATION (right, work, left, 4, 0x0f0f0f0f) DO_PERMUTATION (right, work, left, 0, 0x10101010) left = (leftkey_swap[(left >> 0) & 0xf] << 3) | (leftkey_swap[(left >> 8) & 0xf] << 2) | (leftkey_swap[(left >> 16) & 0xf] << 1) | (leftkey_swap[(left >> 24) & 0xf]) | (leftkey_swap[(left >> 5) & 0xf] << 7) | (leftkey_swap[(left >> 13) & 0xf] << 6) | (leftkey_swap[(left >> 21) & 0xf] << 5) | (leftkey_swap[(left >> 29) & 0xf] << 4); left &= 0x0fffffff; right = (rightkey_swap[(right >> 1) & 0xf] << 3) | (rightkey_swap[(right >> 9) & 0xf] << 2) | (rightkey_swap[(right >> 17) & 0xf] << 1) | (rightkey_swap[(right >> 25) & 0xf]) | (rightkey_swap[(right >> 4) & 0xf] << 7) | (rightkey_swap[(right >> 12) & 0xf] << 6) | (rightkey_swap[(right >> 20) & 0xf] << 5) | (rightkey_swap[(right >> 28) & 0xf] << 4); right &= 0x0fffffff; for (round = 0; round < 16; ++round) { left = ((left << encrypt_rotate_tab[round]) | (left >> (28 - encrypt_rotate_tab[round]))) & 0x0fffffff; right = ((right << encrypt_rotate_tab[round]) | (right >> (28 - encrypt_rotate_tab[round]))) & 0x0fffffff; *subkey++ = ((left << 4) & 0x24000000) | ((left << 28) & 0x10000000) | ((left << 14) & 0x08000000) | ((left << 18) & 0x02080000) | ((left << 6) & 0x01000000) | ((left << 9) & 0x00200000) | ((left >> 1) & 0x00100000) | ((left << 10) & 0x00040000) | ((left << 2) & 0x00020000) | ((left >> 10) & 0x00010000) | ((right >> 13) & 0x00002000) | ((right >> 4) & 0x00001000) | ((right << 6) & 0x00000800) | ((right >> 1) & 0x00000400) | ((right >> 14) & 0x00000200) | (right & 0x00000100) | ((right >> 5) & 0x00000020) | ((right >> 10) & 0x00000010) | ((right >> 3) & 0x00000008) | ((right >> 18) & 0x00000004) | ((right >> 26) & 0x00000002) | ((right >> 24) & 0x00000001); *subkey++ = ((left << 15) & 0x20000000) | ((left << 17) & 0x10000000) | ((left << 10) & 0x08000000) | ((left << 22) & 0x04000000) | ((left >> 2) & 0x02000000) | ((left << 1) & 0x01000000) | ((left << 16) & 0x00200000) | ((left << 11) & 0x00100000) | ((left << 3) & 0x00080000) | ((left >> 6) & 0x00040000) | ((left << 15) & 0x00020000) | ((left >> 4) & 0x00010000) | ((right >> 2) & 0x00002000) | ((right << 8) & 0x00001000) | ((right >> 14) & 0x00000808) | ((right >> 9) & 0x00000400) | ((right) & 0x00000200) | ((right << 7) & 0x00000100) | ((right >> 7) & 0x00000020) | ((right >> 3) & 0x00000011) | ((right << 2) & 0x00000004) | ((right >> 21) & 0x00000002); } } /* * Fill a DES context with subkeys calculated from a 64bit key. * Does not check parity bits, but simply ignore them. * Does not check for weak keys. **/ static void des_set_key (PurpleCipherContext *context, const guchar * key) { struct _des_ctx *ctx = purple_cipher_context_get_data(context); int i; des_key_schedule (key, ctx->encrypt_subkeys); for(i=0; i<32; i+=2) { ctx->decrypt_subkeys[i] = ctx->encrypt_subkeys[30-i]; ctx->decrypt_subkeys[i+1] = ctx->encrypt_subkeys[31-i]; } } /* * Electronic Codebook Mode DES encryption/decryption of data according * to 'mode'. **/ static int des_ecb_crypt (struct _des_ctx *ctx, const guint8 * from, guint8 * to, int mode) { guint32 left, right, work; guint32 *keys; keys = mode ? ctx->decrypt_subkeys : ctx->encrypt_subkeys; READ_64BIT_DATA (from, left, right) INITIAL_PERMUTATION (left, work, right) DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys) FINAL_PERMUTATION (right, work, left) WRITE_64BIT_DATA (to, right, left) return 0; } static gint des_encrypt(PurpleCipherContext *context, const guchar data[], size_t len, guchar output[], size_t *outlen) { int offset = 0; int i = 0; int tmp; guint8 buf[8] = {0,0,0,0,0,0,0,0}; while(offset+8<=len) { des_ecb_crypt(purple_cipher_context_get_data(context), data+offset, output+offset, 0); offset+=8; } *outlen = len; if(offset<len) { *outlen += len - offset; tmp = offset; while(tmp<len) { buf[i++] = data[tmp]; tmp++; } des_ecb_crypt(purple_cipher_context_get_data(context), buf, output+offset, 0); } return 0; } static gint des_decrypt(PurpleCipherContext *context, const guchar data[], size_t len, guchar output[], size_t *outlen) { int offset = 0; int i = 0; int tmp; guint8 buf[8] = {0,0,0,0,0,0,0,0}; while(offset+8<=len) { des_ecb_crypt(purple_cipher_context_get_data(context), data+offset, output+offset, 1); offset+=8; } *outlen = len; if(offset<len) { *outlen += len - offset; tmp = offset; while(tmp<len) { buf[i++] = data[tmp]; tmp++; } des_ecb_crypt(purple_cipher_context_get_data(context), buf, output+offset, 1); } return 0; } static void des_init(PurpleCipherContext *context, gpointer extra) { struct _des_ctx *mctx; mctx = g_new0(struct _des_ctx, 1); purple_cipher_context_set_data(context, mctx); } static void des_uninit(PurpleCipherContext *context) { struct _des_ctx *des_context; des_context = purple_cipher_context_get_data(context); memset(des_context, 0, sizeof(*des_context)); g_free(des_context); des_context = NULL; } static PurpleCipherOps DESOps = { NULL, /* Set option */ NULL, /* Get option */ des_init, /* init */ NULL, /* reset */ des_uninit, /* uninit */ NULL, /* set iv */ NULL, /* append */ NULL, /* digest */ des_encrypt, /* encrypt */ des_decrypt, /* decrypt */ NULL, /* set salt */ NULL, /* get salt size */ des_set_key, /* set key */ NULL, /* get key size */ NULL, /* set batch mode */ NULL, /* get batch mode */ NULL, /* get block size */ NULL /* set key with len */ }; /****************************************************************************** * Triple-DES *****************************************************************************/ typedef struct _des3_ctx { PurpleCipherBatchMode mode; guchar iv[8]; /* First key for encryption */ struct _des_ctx key1; /* Second key for decryption */ struct _des_ctx key2; /* Third key for encryption */ struct _des_ctx key3; } des3_ctx[1]; /* * Fill a DES3 context with subkeys calculated from 3 64bit key. * Does not check parity bits, but simply ignore them. * Does not check for weak keys. **/ static void des3_set_key(PurpleCipherContext *context, const guchar * key) { struct _des3_ctx *ctx = purple_cipher_context_get_data(context); int i; des_key_schedule (key + 0, ctx->key1.encrypt_subkeys); des_key_schedule (key + 8, ctx->key2.encrypt_subkeys); des_key_schedule (key + 16, ctx->key3.encrypt_subkeys); for (i = 0; i < 32; i += 2) { ctx->key1.decrypt_subkeys[i] = ctx->key1.encrypt_subkeys[30-i]; ctx->key1.decrypt_subkeys[i+1] = ctx->key1.encrypt_subkeys[31-i]; ctx->key2.decrypt_subkeys[i] = ctx->key2.encrypt_subkeys[30-i]; ctx->key2.decrypt_subkeys[i+1] = ctx->key2.encrypt_subkeys[31-i]; ctx->key3.decrypt_subkeys[i] = ctx->key3.encrypt_subkeys[30-i]; ctx->key3.decrypt_subkeys[i+1] = ctx->key3.encrypt_subkeys[31-i]; } } static gint des3_ecb_encrypt(struct _des3_ctx *ctx, const guchar data[], size_t len, guchar output[], size_t *outlen) { int offset = 0; int i = 0; int tmp; guint8 buf[8] = {0,0,0,0,0,0,0,0}; while (offset + 8 <= len) { des_ecb_crypt(&ctx->key1, data+offset, output+offset, 0); des_ecb_crypt(&ctx->key2, output+offset, buf, 1); des_ecb_crypt(&ctx->key3, buf, output+offset, 0); offset += 8; } *outlen = len; if (offset < len) { *outlen += len - offset; tmp = offset; memset(buf, 0, 8); while (tmp < len) { buf[i++] = data[tmp]; tmp++; } des_ecb_crypt(&ctx->key1, buf, output+offset, 0); des_ecb_crypt(&ctx->key2, output+offset, buf, 1); des_ecb_crypt(&ctx->key3, buf, output+offset, 0); } return 0; } static gint des3_cbc_encrypt(struct _des3_ctx *ctx, const guchar data[], size_t len, guchar output[], size_t *outlen) { int offset = 0; int i = 0; int tmp; guint8 buf[8]; memcpy(buf, ctx->iv, 8); while (offset + 8 <= len) { for (i = 0; i < 8; i++) buf[i] ^= data[offset + i]; des_ecb_crypt(&ctx->key1, buf, output+offset, 0); des_ecb_crypt(&ctx->key2, output+offset, buf, 1); des_ecb_crypt(&ctx->key3, buf, output+offset, 0); memcpy(buf, output+offset, 8); offset += 8; } *outlen = len; if (offset < len) { *outlen += len - offset; tmp = offset; i = 0; while (tmp < len) { buf[i++] ^= data[tmp]; tmp++; } des_ecb_crypt(&ctx->key1, buf, output+offset, 0); des_ecb_crypt(&ctx->key2, output+offset, buf, 1); des_ecb_crypt(&ctx->key3, buf, output+offset, 0); } return 0; } static gint des3_encrypt(PurpleCipherContext *context, const guchar data[], size_t len, guchar output[], size_t *outlen) { struct _des3_ctx *ctx = purple_cipher_context_get_data(context); if (ctx->mode == PURPLE_CIPHER_BATCH_MODE_ECB) { return des3_ecb_encrypt(ctx, data, len, output, outlen); } else if (ctx->mode == PURPLE_CIPHER_BATCH_MODE_CBC) { return des3_cbc_encrypt(ctx, data, len, output, outlen); } else { g_return_val_if_reached(0); } return 0; } static gint des3_ecb_decrypt(struct _des3_ctx *ctx, const guchar data[], size_t len, guchar output[], size_t *outlen) { int offset = 0; int i = 0; int tmp; guint8 buf[8] = {0,0,0,0,0,0,0,0}; while (offset + 8 <= len) { /* NOTE: Apply key in reverse */ des_ecb_crypt(&ctx->key3, data+offset, output+offset, 1); des_ecb_crypt(&ctx->key2, output+offset, buf, 0); des_ecb_crypt(&ctx->key1, buf, output+offset, 1); offset+=8; } *outlen = len; if (offset < len) { *outlen += len - offset; tmp = offset; memset(buf, 0, 8); while (tmp < len) { buf[i++] = data[tmp]; tmp++; } des_ecb_crypt(&ctx->key3, buf, output+offset, 1); des_ecb_crypt(&ctx->key2, output+offset, buf, 0); des_ecb_crypt(&ctx->key1, buf, output+offset, 1); } return 0; } static gint des3_cbc_decrypt(struct _des3_ctx *ctx, const guchar data[], size_t len, guchar output[], size_t *outlen) { int offset = 0; int i = 0; int tmp; guint8 buf[8] = {0,0,0,0,0,0,0,0}; guint8 link[8]; memcpy(link, ctx->iv, 8); while (offset + 8 <= len) { des_ecb_crypt(&ctx->key3, data+offset, output+offset, 1); des_ecb_crypt(&ctx->key2, output+offset, buf, 0); des_ecb_crypt(&ctx->key1, buf, output+offset, 1); for (i = 0; i < 8; i++) output[offset + i] ^= link[i]; memcpy(link, data + offset, 8); offset+=8; } *outlen = len; if(offset<len) { *outlen += len - offset; tmp = offset; memset(buf, 0, 8); i = 0; while(tmp<len) { buf[i++] = data[tmp]; tmp++; } des_ecb_crypt(&ctx->key3, buf, output+offset, 1); des_ecb_crypt(&ctx->key2, output+offset, buf, 0); des_ecb_crypt(&ctx->key1, buf, output+offset, 1); for (i = 0; i < 8; i++) output[offset + i] ^= link[i]; } return 0; } static gint des3_decrypt(PurpleCipherContext *context, const guchar data[], size_t len, guchar output[], size_t *outlen) { struct _des3_ctx *ctx = purple_cipher_context_get_data(context); if (ctx->mode == PURPLE_CIPHER_BATCH_MODE_ECB) { return des3_ecb_decrypt(ctx, data, len, output, outlen); } else if (ctx->mode == PURPLE_CIPHER_BATCH_MODE_CBC) { return des3_cbc_decrypt(ctx, data, len, output, outlen); } else { g_return_val_if_reached(0); } return 0; } static void des3_set_batch(PurpleCipherContext *context, PurpleCipherBatchMode mode) { struct _des3_ctx *ctx = purple_cipher_context_get_data(context); ctx->mode = mode; } static PurpleCipherBatchMode des3_get_batch(PurpleCipherContext *context) { struct _des3_ctx *ctx = purple_cipher_context_get_data(context); return ctx->mode; } static void des3_set_iv(PurpleCipherContext *context, guchar *iv, size_t len) { struct _des3_ctx *ctx; g_return_if_fail(len == 8); ctx = purple_cipher_context_get_data(context); memcpy(ctx->iv, iv, len); } static void des3_init(PurpleCipherContext *context, gpointer extra) { struct _des3_ctx *mctx; mctx = g_new0(struct _des3_ctx, 1); purple_cipher_context_set_data(context, mctx); } static void des3_uninit(PurpleCipherContext *context) { struct _des3_ctx *des3_context; des3_context = purple_cipher_context_get_data(context); memset(des3_context, 0, sizeof(*des3_context)); g_free(des3_context); des3_context = NULL; } static PurpleCipherOps DES3Ops = { NULL, /* Set option */ NULL, /* Get option */ des3_init, /* init */ NULL, /* reset */ des3_uninit, /* uninit */ des3_set_iv, /* set iv */ NULL, /* append */ NULL, /* digest */ des3_encrypt, /* encrypt */ des3_decrypt, /* decrypt */ NULL, /* set salt */ NULL, /* get salt size */ des3_set_key, /* set key */ NULL, /* get key size */ des3_set_batch, /* set batch mode */ des3_get_batch, /* get batch mode */ NULL, /* get block size */ NULL /* set key with len */ }; /****************************************************************************** * Registration *****************************************************************************/ PurpleCipherOps * purple_des_cipher_get_ops(void) { return &DESOps; } PurpleCipherOps * purple_des3_cipher_get_ops(void) { return &DES3Ops; }