← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libav/trusty-proposed

« back to all changes in this revision

Viewing changes to libavutil/xtea.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2013-10-22 23:24:08 UTC
  • mfrom: (1.3.36 sid)
  • Revision ID: package-import@ubuntu.com-20131022232408-b8tvvn4pyzri9mi3
Tags: 6:9.10-1ubuntu1
https://launchpad.net/bugs/1243235
https://launchpad.net/bugs/1180288
https://launchpad.net/bugs/1242802
* Build all -extra flavors from this source package, as libav got demoted
  from main to universe, cf LP: #1243235
* Simplify debian/rules to follow exactly the code that debian executes
* New upstream (LP: #1180288) fixes lots of security issues (LP: #1242802)
* Merge from unstable, remaining changes:
  - build-depend on libtiff5-dev rather than libtiff4-dev,
    avoids FTBFS caused by imlib
  - follow the regular debian codepaths

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavutil/xtea.c
 
1
/*
 
2
 * A 32-bit implementation of the XTEA algorithm
 
3
 * Copyright (c) 2012 Samuel Pitoiset
 
4
 *
 
5
 * loosely based on the implementation of David Wheeler and Roger Needham
 
6
 *
 
7
 * This file is part of Libav.
 
8
 *
 
9
 * Libav is free software; you can redistribute it and/or
 
10
 * modify it under the terms of the GNU Lesser General Public
 
11
 * License as published by the Free Software Foundation; either
 
12
 * version 2.1 of the License, or (at your option) any later version.
 
13
 *
 
14
 * Libav is distributed in the hope that it will be useful,
 
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
17
 * Lesser General Public License for more details.
 
18
 *
 
19
 * You should have received a copy of the GNU Lesser General Public
 
20
 * License along with Libav; if not, write to the Free Software
 
21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
22
 */
 
23
 
 
24
#include "libavutil/intreadwrite.h"
 
25
 
 
26
#include "avutil.h"
 
27
#include "common.h"
 
28
#include "xtea.h"
 
29
 
 
30
void av_xtea_init(AVXTEA *ctx, const uint8_t key[16])
 
31
{
 
32
    int i;
 
33
 
 
34
    for (i = 0; i < 4; i++)
 
35
        ctx->key[i] = AV_RB32(key + (i << 2));
 
36
}
 
37
 
 
38
static void xtea_crypt_ecb(AVXTEA *ctx, uint8_t *dst, const uint8_t *src,
 
39
                           int decrypt, uint8_t *iv)
 
40
{
 
41
    uint32_t v0, v1;
 
42
    int i;
 
43
 
 
44
    v0 = AV_RB32(src);
 
45
    v1 = AV_RB32(src + 4);
 
46
 
 
47
    if (decrypt) {
 
48
        uint32_t delta = 0x9E3779B9, sum = delta * 32;
 
49
 
 
50
        for (i = 0; i < 32; i++) {
 
51
            v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + ctx->key[(sum >> 11) & 3]);
 
52
            sum -= delta;
 
53
            v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + ctx->key[sum & 3]);
 
54
        }
 
55
        if (iv) {
 
56
            v0 ^= AV_RB32(iv);
 
57
            v1 ^= AV_RB32(iv + 4);
 
58
            memcpy(iv, src, 8);
 
59
        }
 
60
    } else {
 
61
        uint32_t sum = 0, delta = 0x9E3779B9;
 
62
 
 
63
        for (i = 0; i < 32; i++) {
 
64
            v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + ctx->key[sum & 3]);
 
65
            sum += delta;
 
66
            v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + ctx->key[(sum >> 11) & 3]);
 
67
        }
 
68
    }
 
69
 
 
70
    AV_WB32(dst, v0);
 
71
    AV_WB32(dst + 4, v1);
 
72
}
 
73
 
 
74
void av_xtea_crypt(AVXTEA *ctx, uint8_t *dst, const uint8_t *src, int count,
 
75
                   uint8_t *iv, int decrypt)
 
76
{
 
77
    int i;
 
78
 
 
79
    if (decrypt) {
 
80
        while (count--) {
 
81
            xtea_crypt_ecb(ctx, dst, src, decrypt, iv);
 
82
 
 
83
            src   += 8;
 
84
            dst   += 8;
 
85
        }
 
86
    } else {
 
87
        while (count--) {
 
88
            if (iv) {
 
89
                for (i = 0; i < 8; i++)
 
90
                    dst[i] = src[i] ^ iv[i];
 
91
                xtea_crypt_ecb(ctx, dst, dst, decrypt, NULL);
 
92
                memcpy(iv, dst, 8);
 
93
            } else {
 
94
                xtea_crypt_ecb(ctx, dst, src, decrypt, NULL);
 
95
            }
 
96
            src   += 8;
 
97
            dst   += 8;
 
98
        }
 
99
    }
 
100
}
 
101
 
 
102
#ifdef TEST
 
103
#include <stdio.h>
 
104
 
 
105
#define XTEA_NUM_TESTS 6
 
106
 
 
107
static const uint8_t xtea_test_key[XTEA_NUM_TESTS][16] = {
 
108
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 
109
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 
110
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 
111
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 
112
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 
113
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 
114
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
115
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 
116
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
117
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 
118
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
119
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
 
120
};
 
121
 
 
122
static const uint8_t xtea_test_pt[XTEA_NUM_TESTS][8] = {
 
123
    { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48 },
 
124
    { 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 },
 
125
    { 0x5a, 0x5b, 0x6e, 0x27, 0x89, 0x48, 0xd7, 0x7f },
 
126
    { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48 },
 
127
    { 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 },
 
128
    { 0x70, 0xe1, 0x22, 0x5d, 0x6e, 0x4e, 0x76, 0x55 }
 
129
};
 
130
 
 
131
static const uint8_t xtea_test_ct[XTEA_NUM_TESTS][8] = {
 
132
    { 0x49, 0x7d, 0xf3, 0xd0, 0x72, 0x61, 0x2c, 0xb5 },
 
133
    { 0xe7, 0x8f, 0x2d, 0x13, 0x74, 0x43, 0x41, 0xd8 },
 
134
    { 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 },
 
135
    { 0xa0, 0x39, 0x05, 0x89, 0xf8, 0xb8, 0xef, 0xa5 },
 
136
    { 0xed, 0x23, 0x37, 0x5a, 0x82, 0x1a, 0x8c, 0x2d },
 
137
    { 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 }
 
138
};
 
139
 
 
140
static void test_xtea(AVXTEA *ctx, uint8_t *dst, const uint8_t *src,
 
141
                      const uint8_t *ref, int len, uint8_t *iv, int dir,
 
142
                      const char *test)
 
143
{
 
144
    av_xtea_crypt(ctx, dst, src, len, iv, dir);
 
145
    if (memcmp(dst, ref, 8*len)) {
 
146
        int i;
 
147
        printf("%s failed\ngot      ", test);
 
148
        for (i = 0; i < 8*len; i++)
 
149
            printf("%02x ", dst[i]);
 
150
        printf("\nexpected ");
 
151
        for (i = 0; i < 8*len; i++)
 
152
            printf("%02x ", ref[i]);
 
153
        printf("\n");
 
154
        exit(1);
 
155
    }
 
156
}
 
157
 
 
158
int main(void)
 
159
{
 
160
    AVXTEA ctx;
 
161
    uint8_t buf[8], iv[8];
 
162
    int i;
 
163
    const uint8_t src[32] = "HelloWorldHelloWorldHelloWorld";
 
164
    uint8_t ct[32];
 
165
    uint8_t pl[32];
 
166
 
 
167
    for (i = 0; i < XTEA_NUM_TESTS; i++) {
 
168
        av_xtea_init(&ctx, xtea_test_key[i]);
 
169
 
 
170
        test_xtea(&ctx, buf, xtea_test_pt[i], xtea_test_ct[i], 1, NULL, 0, "encryption");
 
171
        test_xtea(&ctx, buf, xtea_test_ct[i], xtea_test_pt[i], 1, NULL, 1, "decryption");
 
172
 
 
173
        /* encrypt */
 
174
        memcpy(iv, "HALLO123", 8);
 
175
        av_xtea_crypt(&ctx, ct, src, 4, iv, 0);
 
176
 
 
177
        /* decrypt into pl */
 
178
        memcpy(iv, "HALLO123", 8);
 
179
        test_xtea(&ctx, pl, ct, src, 4, iv, 1, "CBC decryption");
 
180
 
 
181
        memcpy(iv, "HALLO123", 8);
 
182
        test_xtea(&ctx, ct, ct, src, 4, iv, 1, "CBC inplace decryption");
 
183
    }
 
184
    printf("Test encryption/decryption success.\n");
 
185
 
 
186
    return 0;
 
187
}
 
188
 
 
189
#endif