Add and use a public API for RC4 and DES, analogous to the AES API.

Originally committed as revision 16970 to svn://svn.ffmpeg.org/ffmpeg/trunk

libavformat/asfcrypt.c

@@ -136,6 +136,8 @@ static uint64_t multiswap_dec(const uint32_t keys[12], uint64_t key, uint64_t da
 }
 
 void ff_asfcrypt_dec(const uint8_t key[20], uint8_t *data, int len) {
+    struct AVDES des;
+    struct AVRC4 rc4;
     int num_qwords = len >> 3;
     uint64_t *qwords = (uint64_t *)data;
     uint64_t rc4buff[8];
@@ -150,17 +152,18 @@ void ff_asfcrypt_dec(const uint8_t key[20], uint8_t *data, int len) {
     }
 
     memset(rc4buff, 0, sizeof(rc4buff));
-    ff_rc4_enc(key, 12, (uint8_t *)rc4buff, sizeof(rc4buff));
+    av_rc4_init(&rc4, key, 12 * 8, 1);
+    av_rc4_crypt(&rc4, (uint8_t *)rc4buff, NULL, sizeof(rc4buff), NULL, 1);
     multiswap_init((uint8_t *)rc4buff, ms_keys);
 
     packetkey = qwords[num_qwords - 1];
     packetkey ^= rc4buff[7];
-    packetkey = be2me_64(packetkey);
-    packetkey = ff_des_encdec(packetkey, AV_RB64(key + 12), 1);
-    packetkey = be2me_64(packetkey);
+    av_des_init(&des, key + 12, 64, 1);
+    av_des_crypt(&des, (uint8_t *)&packetkey, (uint8_t *)&packetkey, 1, NULL, 1);
     packetkey ^= rc4buff[6];
 
-    ff_rc4_enc((uint8_t *)&packetkey, 8, data, len);
+    av_rc4_init(&rc4, (uint8_t *)&packetkey, 64, 1);
+    av_rc4_crypt(&rc4, data, data, len, NULL, 1);
 
     ms_state = 0;
     for (i = 0; i < num_qwords - 1; i++, qwords++)

libavutil/des.c

@@ -19,9 +19,13 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include <inttypes.h>
+#include "avutil.h"
 #include "common.h"
+#include "intreadwrite.h"
 #include "des.h"
 
+typedef struct AVDES AVDES;
+
 #define T(a, b, c, d, e, f, g, h) 64-a,64-b,64-c,64-d,64-e,64-f,64-g,64-h
 static const uint8_t IP_shuffle[] = {
     T(58, 50, 42, 34, 26, 18, 10, 2),
@@ -249,9 +253,8 @@ static uint64_t key_shift_left(uint64_t CDn) {
     return CDn;
 }
 
-uint64_t ff_des_encdec(uint64_t in, uint64_t key, int decrypt) {
+static void gen_roundkeys(uint64_t K[16], uint64_t key) {
     int i;
-    uint64_t K[16];
     // discard parity bits from key and shuffle it into C and D parts
     uint64_t CDn = shuffle(key, PC1_shuffle, sizeof(PC1_shuffle));
     // generate round keys
@@ -261,6 +264,10 @@ uint64_t ff_des_encdec(uint64_t in, uint64_t key, int decrypt) {
             CDn = key_shift_left(CDn);
         K[i] = shuffle(CDn, PC2_shuffle, sizeof(PC2_shuffle));
     }
+}
+
+static uint64_t des_encdec(uint64_t in, uint64_t K[16], int decrypt) {
+    int i;
     // used to apply round keys in reverse order for decryption
     decrypt = decrypt ? 15 : 0;
     // shuffle irrelevant to security but to ease hardware implementations
@@ -277,6 +284,42 @@ uint64_t ff_des_encdec(uint64_t in, uint64_t key, int decrypt) {
     return in;
 }
 
+#if LIBAVUTIL_VERSION_MAJOR < 50
+uint64_t ff_des_encdec(uint64_t in, uint64_t key, int decrypt) {
+    uint64_t K[16];
+    gen_roundkeys(K, key);
+    return des_encdec(in, K, decrypt);
+}
+#endif
+
+int av_des_init(AVDES *d, const uint8_t *key, int key_bits, int decrypt) {
+    if (key_bits != 64)
+        return -1;
+    d->triple_des = 0;
+    gen_roundkeys(d->round_keys[0], AV_RB64(key));
+    return 0;
+}
+
+void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt) {
+    uint64_t iv_val = iv ? be2me_64(*(uint64_t *)iv) : 0;
+    while (count-- > 0) {
+        uint64_t dst_val;
+        uint64_t src_val = src ? be2me_64(*(const uint64_t *)src) : 0;
+        if (decrypt) {
+            dst_val = des_encdec(src_val, d->round_keys[0], 1) ^ iv_val;
+            iv_val = iv ? src_val : 0;
+        } else {
+            dst_val = des_encdec(src_val ^ iv_val, d->round_keys[0], 0);
+            iv_val = iv ? dst_val : 0;
+        }
+        *(uint64_t *)dst = be2me_64(dst_val);
+        src += 8;
+        dst += 8;
+    }
+    if (iv)
+        *(uint64_t *)iv = be2me_64(iv_val);
+}
+
 #ifdef TEST
 #undef printf
 #undef rand

libavutil/des.h

@@ -23,18 +23,30 @@
 #define AVUTIL_DES_H
 
 #include <stdint.h>
-#include "common.h"
+
+struct AVDES {
+    uint64_t round_keys[3][16];
+    int triple_des;
+};
+
+/**
+ * \brief Initializes an AVDES context.
+ *
+ * \param key_bits must be 64
+ * \param decrypt 0 for encryption, 1 for decryption
+ */
+int av_des_init(struct AVDES *d, const uint8_t *key, int key_bits, int decrypt);
 
 /**
- * \brief Encrypt/decrypt a 64-bit block of data with DES.
- * \param in data to process
- * \param key key to use for encryption/decryption
- * \param decrypt if 0 encrypt, else decrypt
- * \return processed data
+ * \brief Encrypts / decrypts using the DES algorithm.
  *
- * If your input data is in 8-bit blocks, treat it as big-endian
- * (use e.g. AV_RB64 and AV_WB64).
+ * \param count number of 8 byte blocks
+ * \param dst destination array, can be equal to src, must be 8-byte aligned
+ * \param src source array, can be equal to dst, must be 8-byte aligned, may be NULL
+ * \param iv initialization vector for CBC mode, if NULL then ECB will be used,
+ *           must be 8-byte aligned
+ * \param decrypt 0 for encryption, 1 for decryption
  */
-uint64_t ff_des_encdec(uint64_t in, uint64_t key, int decrypt) av_const;
+void av_des_crypt(struct AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt);
 
 #endif /* AVUTIL_DES_H */

libavutil/rc4.c

@@ -20,13 +20,19 @@
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include "avutil.h"
 #include "common.h"
 #include "rc4.h"
 
-void ff_rc4_enc(const uint8_t *key, int keylen, uint8_t *data, int datalen) {
+typedef struct AVRC4 AVRC4;
+
+int av_rc4_init(AVRC4 *r, const uint8_t *key, int key_bits, int decrypt) {
     int i, j;
-    uint8_t x, y;
-    uint8_t state[256];
+    uint8_t y;
+    uint8_t *state = r->state;
+    int keylen = key_bits >> 3;
+    if (key_bits & 7)
+        return -1;
     for (i = 0; i < 256; i++)
         state[i] = i;
     y = 0;
@@ -36,13 +42,28 @@ void ff_rc4_enc(const uint8_t *key, int keylen, uint8_t *data, int datalen) {
         y += state[i] + key[j];
         FFSWAP(uint8_t, state[i], state[y]);
     }
-    // state initialized, now do the real encryption
-    x = 1; y = state[1];
-    while (datalen-- > 0) {
+    r->x = 1;
+    r->y = state[1];
+    return 0;
+}
+
+void av_rc4_crypt(AVRC4 *r, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt) {
+    uint8_t x = r->x, y = r->y;
+    uint8_t *state = r->state;
+    while (count-- > 0) {
         uint8_t sum = state[x] + state[y];
         FFSWAP(uint8_t, state[x], state[y]);
-        *data++ ^= state[sum];
+        *dst++ = src ? *src++ ^ state[sum] : state[sum];
         x++;
         y += state[x];
     }
+    r->x = x; r->y = y;
+}
+
+#if LIBAVUTIL_VERSION_MAJOR < 50
+void ff_rc4_enc(const uint8_t *key, int keylen, uint8_t *data, int datalen) {
+    AVRC4 r;
+    av_rc4_init(&r, key, keylen * 8, 0);
+    av_rc4_crypt(&r, data, data, datalen, NULL, 0);
 }
+#endif

libavutil/rc4.h

@@ -23,6 +23,28 @@
 
 #include <stdint.h>
 
-void ff_rc4_enc(const uint8_t *key, int keylen, uint8_t *data, int datalen);
+struct AVRC4 {
+    uint8_t state[256];
+    int x, y;
+};
+
+/**
+ * \brief Initializes an AVRC4 context.
+ *
+ * \param key_bits must be a multiple of 8
+ * \param decrypt 0 for encryption, 1 for decryption, currently has no effect
+ */
+int av_rc4_init(struct AVRC4 *d, const uint8_t *key, int key_bits, int decrypt);
+
+/**
+ * \brief Encrypts / decrypts using the RC4 algorithm.
+ *
+ * \param count number of bytes
+ * \param dst destination array, can be equal to src
+ * \param src source array, can be equal to dst, may be NULL
+ * \param iv not (yet) used for RC4, should be NULL
+ * \param decrypt 0 for encryption, 1 for decryption, not (yet) used
+ */
+void av_rc4_crypt(struct AVRC4 *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt);
 
 #endif /* AVUTIL_RC4_H */