diff -r 8bcae3a0b165 -r 5f88ba22172b libpurple/ciphers/descipher.c --- a/libpurple/ciphers/descipher.c Thu Jun 15 10:48:26 2017 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,581 +0,0 @@ -/* - * Original des taken from gpg - * - * des.c - 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. - * - * 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. - * - * 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 "internal.h" -#include "glibcompat.h" - -#include "descipher.h" -#include "enums.h" - -#include - -/****************************************************************************** - * Structs - *****************************************************************************/ -#define PURPLE_DES_CIPHER_GET_PRIVATE(obj) \ - (G_TYPE_INSTANCE_GET_PRIVATE((obj), PURPLE_TYPE_DES_CIPHER, PurpleDESCipherPrivate)) - -typedef struct { - guint32 encrypt_subkeys[32]; - guint32 decrypt_subkeys[32]; -} PurpleDESCipherPrivate; - -/****************************************************************************** - * Enums - *****************************************************************************/ -enum { - PROP_NONE, - PROP_KEY, - PROP_LAST, -}; - -/****************************************************************************** - * Globals - *****************************************************************************/ -static GObjectClass *parent_class = NULL; -static GParamSpec *properties[PROP_LAST]; - -/* - * The s-box values are permuted according to the 'primitive function P' - */ -static 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 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 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 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 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 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 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 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 guint32 leftkey_swap[16] = { - 0x00000000, 0x00000001, 0x00000100, 0x00000101, 0x00010000, 0x00010001, - 0x00010100, 0x00010101, 0x01000000, 0x01000001, 0x01000100, 0x01000101, - 0x01010000, 0x01010001, 0x01010100, 0x01010101 -}; - -static 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 guint8 encrypt_rotate_tab[16] = { - 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 -}; - - -/****************************************************************************** - * Helpers - *****************************************************************************/ -/* - * Macro to swap bits across two words - */ -#define DO_PERMUTATION(a, temp, b, offset, mask) \ - temp = ((a>>offset) ^ b) & mask; \ - b ^= temp; \ - a ^= temp<>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; - -/****************************************************************************** - * Cipher Stuff - *****************************************************************************/ -/* - * 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 -purple_des_cipher_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 -purple_des_cipher_set_key(PurpleCipher *cipher, const guchar *key, size_t len) { - PurpleDESCipher *des_cipher = PURPLE_DES_CIPHER(cipher); - PurpleDESCipherPrivate *priv = PURPLE_DES_CIPHER_GET_PRIVATE(des_cipher); - int i; - - g_return_if_fail(len == 8); - - purple_des_cipher_key_schedule(key, priv->encrypt_subkeys); - - for(i = 0; i < 32; i += 2) { - priv->decrypt_subkeys[i] = priv->encrypt_subkeys[30 - i]; - priv->decrypt_subkeys[i + 1] = priv->encrypt_subkeys[31 - i]; - } - - g_object_notify_by_pspec(G_OBJECT(cipher), properties[PROP_KEY]); -} - -static size_t -purple_des_cipher_get_key_size(PurpleCipher *cipher) -{ - return 8; -} - -/* - * Electronic Codebook Mode DES encryption/decryption of data according to - * 'mode'. - */ -int -purple_des_cipher_ecb_crypt(PurpleDESCipher *des_cipher, const guint8 * from, guint8 * to, - int mode) -{ - guint32 left, right, work; - guint32 *keys; - PurpleDESCipherPrivate *priv = PURPLE_DES_CIPHER_GET_PRIVATE(des_cipher); - - keys = mode ? priv->decrypt_subkeys : - priv->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 ssize_t -purple_des_cipher_encrypt(PurpleCipher *cipher, const guchar input[], - size_t in_len, guchar output[], size_t out_size) -{ - PurpleDESCipher *des_cipher = PURPLE_DES_CIPHER(cipher); - - gsize offset = 0; - int i = 0; - gsize tmp; - guint8 buf[8] = {0,0,0,0,0,0,0,0}; - gsize out_len; - - g_return_val_if_fail(out_size >= in_len, -1); - - while(offset + 8 <= in_len) { - purple_des_cipher_ecb_crypt(des_cipher, input + offset, output + offset, 0); - offset += 8; - } - - out_len = in_len; - - if(offset= offset, -1); - out_len += in_len - offset; - g_return_val_if_fail(out_size >= out_len, -1); - tmp = offset; - while(tmp= in_len, -1); - - while(offset + 8 <= in_len) { - purple_des_cipher_ecb_crypt(des_cipher, input + offset, output + offset, 1); - offset += 8; - } - - out_len = in_len; - if(offset= offset, -1); - out_len += in_len - offset; - g_return_val_if_fail(out_size >= out_len, -1); - tmp = offset; - while(tmpset_property = purple_des_cipher_set_property; - - cipher_class->encrypt = purple_des_cipher_encrypt; - cipher_class->decrypt = purple_des_cipher_decrypt; - cipher_class->set_key = purple_des_cipher_set_key; - cipher_class->get_key_size = purple_des_cipher_get_key_size; - - g_type_class_add_private(klass, sizeof(PurpleDESCipherPrivate)); - - properties[PROP_KEY] = g_param_spec_string("key", "key", "key", NULL, - G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); - - g_object_class_install_properties(obj_class, PROP_LAST, properties); -} - -/****************************************************************************** - * API - *****************************************************************************/ -GType -purple_des_cipher_get_type(void) { - static GType type = 0; - - if(type == 0) { - static const GTypeInfo info = { - .class_size = sizeof(PurpleDESCipherClass), - .class_init = (GClassInitFunc)purple_des_cipher_class_init, - .instance_size = sizeof(PurpleDESCipher), - .instance_init = (GInstanceInitFunc)purple_cipher_reset, - }; - - type = g_type_register_static(PURPLE_TYPE_CIPHER, - "PurpleDESCipher", - &info, 0); - } - - return type; -} - -/** - * purple_des_cipher_new: - * - * Creates a new #PurpleCipher instance which implements the DES block cipher. - * - * Return Value: The new DES implementation of #PurpleCipher. - */ -PurpleCipher * -purple_des_cipher_new(void) { - return g_object_new(PURPLE_TYPE_DES_CIPHER, NULL); -}