OpenCores
URL https://opencores.org/ocsvn/csa/csa/trunk

Subversion Repositories csa

[/] [csa/] [trunk/] [sw_sim/] [csa.c] - Blame information for rev 41

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 10 simon111 
/*
2 
    dvb common scrambling algorithm
3 
 
4 
    refs:
5 
        uk patent: gb 2322 994
6 
        uk patent: gb 2322 995
7 
        freedec v2.1
8 
        iso/iec 13818-1
9 
        etr289 / dvb document a007
10 
 
11 
*/
12 
 
13 
#include <memory.h>
14 15 simon111 
#include <stdio.h>
15 10 simon111 
#include "csa.h"
16 
 
17 20 simon111 
#include "misc.h"
18 
 
19 10 simon111 
#ifndef NULL
20 
#define NULL 0
21 
#endif
22 
 
23 
/* stream cypher */
24 
 
25 
/*  107 state bits */
26 
/*  26 nibbles (4 bit) */
27 
/*  +  3 bits */
28 
/*  reg A[1]-A[10], 10 nibbles */
29 
/*  reg B[1]-B[10], 10 nibbles */
30 
/*  reg X,           1 nibble */
31 
/*  reg Y,           1 nibble */
32 
/*  reg Z,           1 nibble */
33 
/*  reg D,           1 nibble */
34 
/*  reg E,           1 nibble */
35 
/*  reg F,           1 nibble */
36 
/*  reg p,           1 bit */
37 
/*  reg q,           1 bit */
38 
/*  reg r,           1 bit */
39 
 
40 
int sbox1[0x20] = {2,0,1,1,2,3,3,0, 3,2,2,0,1,1,0,3, 0,3,3,0,2,2,1,1, 2,2,0,3,1,1,3,0};
41 
int sbox2[0x20] = {3,1,0,2,2,3,3,0, 1,3,2,1,0,0,1,2, 3,1,0,3,3,2,0,2, 0,0,1,2,2,1,3,1};
42 
int sbox3[0x20] = {2,0,1,2,2,3,3,1, 1,1,0,3,3,0,2,0, 1,3,0,1,3,0,2,2, 2,0,1,2,0,3,3,1};
43 
int sbox4[0x20] = {3,1,2,3,0,2,1,2, 1,2,0,1,3,0,0,3, 1,0,3,1,2,3,0,3, 0,3,2,0,1,2,2,1};
44 
int sbox5[0x20] = {2,0,0,1,3,2,3,2, 0,1,3,3,1,0,2,1, 2,3,2,0,0,3,1,1, 1,0,3,2,3,1,0,2};
45 
int sbox6[0x20] = {0,1,2,3,1,2,2,0, 0,1,3,0,2,3,1,3, 2,3,0,2,3,0,1,1, 2,1,1,2,0,3,3,0};
46 
int sbox7[0x20] = {0,3,2,2,3,0,0,1, 3,0,1,3,1,2,2,1, 1,0,3,3,0,1,1,2, 2,3,1,0,2,3,0,2};
47 
 
48 
void stream_cypher(int init, unsigned char *CK, unsigned char *sb, unsigned char *cb) {
49 
    int i,j;
50 
    int in1;        /*  most  significant nibble of input byte */
51 
    int in2;        /*  least significant nibble of input byte */
52 
    int op;
53 
    int extra_B;
54 
    int s1,s2,s3,s4,s5,s6,s7;
55 
    int next_A1;
56 
    int next_B1;
57 
    int next_E;
58 
 
59 
    static int A[11];
60 
    static int B[11];
61 
    static int X;
62 
    static int Y;
63 
    static int Z;
64 
    static int D;
65 
    static int E;
66 
    static int F;
67 
    static int p;
68 
    static int q;
69 
    static int r;
70 
 
71 
    /*  reset */
72 
    if (init) {
73 
        /*  load first 32 bits of CK into A[1]..A[8] */
74 
        /*  load last  32 bits of CK into B[1]..B[8] */
75 
        /*  all other regs = 0 */
76 
        A[1] = (CK[0] >> 4) & 0xf;
77 
        A[2] = (CK[0] >> 0) & 0xf;
78 
        A[3] = (CK[1] >> 4) & 0xf;
79 
        A[4] = (CK[1] >> 0) & 0xf;
80 
        A[5] = (CK[2] >> 4) & 0xf;
81 
        A[6] = (CK[2] >> 0) & 0xf;
82 
        A[7] = (CK[3] >> 4) & 0xf;
83 
        A[8] = (CK[3] >> 0) & 0xf;
84 
        A[9] = 0;
85 
        A[10] = 0;
86 
        B[1] = (CK[4] >> 4) & 0xf;
87 
        B[2] = (CK[4] >> 0) & 0xf;
88 
        B[3] = (CK[5] >> 4) & 0xf;
89 
        B[4] = (CK[5] >> 0) & 0xf;
90 
        B[5] = (CK[6] >> 4) & 0xf;
91 
        B[6] = (CK[6] >> 0) & 0xf;
92 
        B[7] = (CK[7] >> 4) & 0xf;
93 
        B[8] = (CK[7] >> 0) & 0xf;
94 
        B[9] = 0;
95 
        B[10] = 0;
96 
 
97 
        X=0;
98 
        Y=0;
99 
        Z=0;
100 
        D=0;
101 
        E=0;
102 
        F=0;
103 
        p=0;
104 
        q=0;
105 
        r=0;
106 
    } /* init */
107 
 
108 20 simon111 
 
109 
 
110 10 simon111 
    /*  8 bytes per operation */
111 
    for(i=0; i<8; i++) {
112 
        if (init) {
113 
            in1 = (sb[i] >> 4) & 0x0f;
114 
            in2 = (sb[i] >> 0) & 0x0f;
115 
        } /* init */
116 
        op = 0;
117 
        /*  2 bits per iteration */
118 
        for(j=0; j<4; j++) {
119 
            /*  from A[1]..A[10], 35 bits are selected as inputs to 7 s-boxes */
120 
            /*  5 bits input per s-box, 2 bits output per s-box */
121 
            s1 = sbox1[ (((A[4]>>0)&1)<<4) | (((A[1]>>2)&1)<<3) | (((A[6]>>1)&1)<<2) | (((A[7]>>3)&1)<<1) | (((A[9]>>0)&1)<<0) ];
122 
            s2 = sbox2[ (((A[2]>>1)&1)<<4) | (((A[3]>>2)&1)<<3) | (((A[6]>>3)&1)<<2) | (((A[7]>>0)&1)<<1) | (((A[9]>>1)&1)<<0) ];
123 
            s3 = sbox3[ (((A[1]>>3)&1)<<4) | (((A[2]>>0)&1)<<3) | (((A[5]>>1)&1)<<2) | (((A[5]>>3)&1)<<1) | (((A[6]>>2)&1)<<0) ];
124 
            s4 = sbox4[ (((A[3]>>3)&1)<<4) | (((A[1]>>1)&1)<<3) | (((A[2]>>3)&1)<<2) | (((A[4]>>2)&1)<<1) | (((A[8]>>0)&1)<<0) ];
125 
            s5 = sbox5[ (((A[5]>>2)&1)<<4) | (((A[4]>>3)&1)<<3) | (((A[6]>>0)&1)<<2) | (((A[8]>>1)&1)<<1) | (((A[9]>>2)&1)<<0) ];
126 
            s6 = sbox6[ (((A[3]>>1)&1)<<4) | (((A[4]>>1)&1)<<3) | (((A[5]>>0)&1)<<2) | (((A[7]>>2)&1)<<1) | (((A[9]>>3)&1)<<0) ];
127 
            s7 = sbox7[ (((A[2]>>2)&1)<<4) | (((A[3]>>0)&1)<<3) | (((A[7]>>1)&1)<<2) | (((A[8]>>2)&1)<<1) | (((A[8]>>3)&1)<<0) ];
128 
 
129 
            /*  use 4x4 xor to produce extra nibble for T3 */
130 
            extra_B = ( ((B[3]&1)<<3) ^ ((B[6]&2)<<2) ^ ((B[7]&4)<<1) ^ ((B[9]&8)>>0) ) |
131 
                      ( ((B[6]&1)<<2) ^ ((B[8]&2)<<1) ^ ((B[3]&8)>>1) ^ ((B[4]&4)>>0) ) |
132 
                      ( ((B[5]&8)>>2) ^ ((B[8]&4)>>1) ^ ((B[4]&1)<<1) ^ ((B[5]&2)>>0) ) |
133 
                      ( ((B[9]&4)>>2) ^ ((B[6]&8)>>3) ^ ((B[3]&2)>>1) ^ ((B[8]&1)>>0) ) ;
134 22 simon111 
 
135 10 simon111 
            /*  T1 = xor all inputs */
136 
            /*  in1,in2, D are only used in T1 during initialisation, not generation */
137 
            next_A1 = A[10] ^ X;
138 
            if (init)
139 22 simon111 
                                next_A1 = next_A1 ^ D ^ ((j % 2) ? in2 : in1);
140 10 simon111 
 
141 20 simon111 
 
142 10 simon111 
            /*  T2 =  xor all inputs */
143 
            /*  in1,in2 are only used in T1 during initialisation, not generation */
144 
            /*  if p=0, use this, if p=1, rotate the result left */
145 
            next_B1 = B[7] ^ B[10] ^ Y;
146 
            if (init)
147 22 simon111 
                                next_B1 = next_B1 ^ ((j % 2) ? in1 : in2);
148 10 simon111 
 
149 
            /*  if p=1, rotate left */
150 
            if (p)
151 22 simon111 
                                next_B1 = ( (next_B1 << 1) | ((next_B1 >> 3) & 1) ) & 0xf;
152 10 simon111 
 
153 
            /*  T3 = xor all inputs */
154 
            D = E ^ Z ^ extra_B;
155 
 
156 
            /*  T4 = sum, carry of Z + E + r */
157 
            next_E = F;
158 
            if (q) {
159 
                F = Z + E + r;
160 
                /*  r is the carry */
161 
                r = (F >> 4) & 1;
162 
                F = F & 0x0f;
163 
            } /* q */
164 
            else {
165 
                F = E;
166 
            }
167 
            E = next_E;
168 
 
169 
            A[10] = A[9];
170 
            A[9] = A[8];
171 
            A[8] = A[7];
172 
            A[7] = A[6];
173 
            A[6] = A[5];
174 
            A[5] = A[4];
175 
            A[4] = A[3];
176 
            A[3] = A[2];
177 
            A[2] = A[1];
178 
            A[1]= next_A1;
179 
 
180 
            B[10] = B[9];
181 
            B[9] = B[8];
182 
            B[8] = B[7];
183 
            B[7] = B[6];
184 
            B[6] = B[5];
185 
            B[5] = B[4];
186 
            B[4] = B[3];
187 
            B[3] = B[2];
188 
            B[2] = B[1];
189 
            B[1] = next_B1;
190 
 
191 
            X = ((s4&1)<<3) | ((s3&1)<<2) | (s2&2) | ((s1&2)>>1);
192 
            Y = ((s6&1)<<3) | ((s5&1)<<2) | (s4&2) | ((s3&2)>>1);
193 
            Z = ((s2&1)<<3) | ((s1&1)<<2) | (s6&2) | ((s5&2)>>1);
194 
            p = (s7&2)>>1;
195 
            q = (s7&1);
196 
 
197 
            /*  require 4 loops per output byte */
198 
            /*  2 output bits are a function of the 4 bits of D */
199 
            /*  xor 2 by 2 */
200 
            op = (op << 2)^ ( (((D^(D>>1))>>1)&2) | ((D^(D>>1))&1) );
201 
        }
202 
        /*  return input data during init */
203 
        cb[i] = (init) ? sb[i] : op;
204 
    }
205 
}
206 
 
207 
/* block cypher */
208 
 
209 
/*  key preparation */
210 
unsigned char key_perm[0x40] = {
211 
    0x12,0x24,0x09,0x07,0x2A,0x31,0x1D,0x15,0x1C,0x36,0x3E,0x32,0x13,0x21,0x3B,0x40,
212 
    0x18,0x14,0x25,0x27,0x02,0x35,0x1B,0x01,0x22,0x04,0x0D,0x0E,0x39,0x28,0x1A,0x29,
213 
    0x33,0x23,0x34,0x0C,0x16,0x30,0x1E,0x3A,0x2D,0x1F,0x08,0x19,0x17,0x2F,0x3D,0x11,
214 
    0x3C,0x05,0x38,0x2B,0x0B,0x06,0x0A,0x2C,0x20,0x3F,0x2E,0x0F,0x03,0x26,0x10,0x37,
215 
};
216 
 
217 
/*  block - sbox */
218 
unsigned char block_sbox[0x100] = {
219 
    0x3A,0xEA,0x68,0xFE,0x33,0xE9,0x88,0x1A,0x83,0xCF,0xE1,0x7F,0xBA,0xE2,0x38,0x12,
220 
    0xE8,0x27,0x61,0x95,0x0C,0x36,0xE5,0x70,0xA2,0x06,0x82,0x7C,0x17,0xA3,0x26,0x49,
221 
    0xBE,0x7A,0x6D,0x47,0xC1,0x51,0x8F,0xF3,0xCC,0x5B,0x67,0xBD,0xCD,0x18,0x08,0xC9,
222 
    0xFF,0x69,0xEF,0x03,0x4E,0x48,0x4A,0x84,0x3F,0xB4,0x10,0x04,0xDC,0xF5,0x5C,0xC6,
223 
    0x16,0xAB,0xAC,0x4C,0xF1,0x6A,0x2F,0x3C,0x3B,0xD4,0xD5,0x94,0xD0,0xC4,0x63,0x62,
224 
    0x71,0xA1,0xF9,0x4F,0x2E,0xAA,0xC5,0x56,0xE3,0x39,0x93,0xCE,0x65,0x64,0xE4,0x58,
225 
    0x6C,0x19,0x42,0x79,0xDD,0xEE,0x96,0xF6,0x8A,0xEC,0x1E,0x85,0x53,0x45,0xDE,0xBB,
226 
    0x7E,0x0A,0x9A,0x13,0x2A,0x9D,0xC2,0x5E,0x5A,0x1F,0x32,0x35,0x9C,0xA8,0x73,0x30,
227 
 
228 
    0x29,0x3D,0xE7,0x92,0x87,0x1B,0x2B,0x4B,0xA5,0x57,0x97,0x40,0x15,0xE6,0xBC,0x0E,
229 
    0xEB,0xC3,0x34,0x2D,0xB8,0x44,0x25,0xA4,0x1C,0xC7,0x23,0xED,0x90,0x6E,0x50,0x00,
230 
    0x99,0x9E,0x4D,0xD9,0xDA,0x8D,0x6F,0x5F,0x3E,0xD7,0x21,0x74,0x86,0xDF,0x6B,0x05,
231 
    0x8E,0x5D,0x37,0x11,0xD2,0x28,0x75,0xD6,0xA7,0x77,0x24,0xBF,0xF0,0xB0,0x02,0xB7,
232 
    0xF8,0xFC,0x81,0x09,0xB1,0x01,0x76,0x91,0x7D,0x0F,0xC8,0xA0,0xF2,0xCB,0x78,0x60,
233 
    0xD1,0xF7,0xE0,0xB5,0x98,0x22,0xB3,0x20,0x1D,0xA6,0xDB,0x7B,0x59,0x9F,0xAE,0x31,
234 
    0xFB,0xD3,0xB6,0xCA,0x43,0x72,0x07,0xF4,0xD8,0x41,0x14,0x55,0x0D,0x54,0x8B,0xB9,
235 
    0xAD,0x46,0x0B,0xAF,0x80,0x52,0x2C,0xFA,0x8C,0x89,0x66,0xFD,0xB2,0xA9,0x9B,0xC0,
236 
};
237 
 
238 
/*  block - perm */
239 
unsigned long block_perm[0x100] = {
240 
    0x00,0x02,0x80,0x82,0x20,0x22,0xA0,0xA2, 0x10,0x12,0x90,0x92,0x30,0x32,0xB0,0xB2,
241 
    0x04,0x06,0x84,0x86,0x24,0x26,0xA4,0xA6, 0x14,0x16,0x94,0x96,0x34,0x36,0xB4,0xB6,
242 
    0x40,0x42,0xC0,0xC2,0x60,0x62,0xE0,0xE2, 0x50,0x52,0xD0,0xD2,0x70,0x72,0xF0,0xF2,
243 
    0x44,0x46,0xC4,0xC6,0x64,0x66,0xE4,0xE6, 0x54,0x56,0xD4,0xD6,0x74,0x76,0xF4,0xF6,
244 
    0x01,0x03,0x81,0x83,0x21,0x23,0xA1,0xA3, 0x11,0x13,0x91,0x93,0x31,0x33,0xB1,0xB3,
245 
    0x05,0x07,0x85,0x87,0x25,0x27,0xA5,0xA7, 0x15,0x17,0x95,0x97,0x35,0x37,0xB5,0xB7,
246 
    0x41,0x43,0xC1,0xC3,0x61,0x63,0xE1,0xE3, 0x51,0x53,0xD1,0xD3,0x71,0x73,0xF1,0xF3,
247 
    0x45,0x47,0xC5,0xC7,0x65,0x67,0xE5,0xE7, 0x55,0x57,0xD5,0xD7,0x75,0x77,0xF5,0xF7,
248 
 
249 
    0x08,0x0A,0x88,0x8A,0x28,0x2A,0xA8,0xAA, 0x18,0x1A,0x98,0x9A,0x38,0x3A,0xB8,0xBA,
250 
    0x0C,0x0E,0x8C,0x8E,0x2C,0x2E,0xAC,0xAE, 0x1C,0x1E,0x9C,0x9E,0x3C,0x3E,0xBC,0xBE,
251 
    0x48,0x4A,0xC8,0xCA,0x68,0x6A,0xE8,0xEA, 0x58,0x5A,0xD8,0xDA,0x78,0x7A,0xF8,0xFA,
252 
    0x4C,0x4E,0xCC,0xCE,0x6C,0x6E,0xEC,0xEE, 0x5C,0x5E,0xDC,0xDE,0x7C,0x7E,0xFC,0xFE,
253 
    0x09,0x0B,0x89,0x8B,0x29,0x2B,0xA9,0xAB, 0x19,0x1B,0x99,0x9B,0x39,0x3B,0xB9,0xBB,
254 
    0x0D,0x0F,0x8D,0x8F,0x2D,0x2F,0xAD,0xAF, 0x1D,0x1F,0x9D,0x9F,0x3D,0x3F,0xBD,0xBF,
255 
    0x49,0x4B,0xC9,0xCB,0x69,0x6B,0xE9,0xEB, 0x59,0x5B,0xD9,0xDB,0x79,0x7B,0xF9,0xFB,
256 
    0x4D,0x4F,0xCD,0xCF,0x6D,0x6F,0xED,0xEF, 0x5D,0x5F,0xDD,0xDF,0x7D,0x7F,0xFD,0xFF,
257 
};
258 
 
259 13 simon111 
void key_schedule(unsigned char *CK, int *kk)
260 
{
261 10 simon111 
    int i,j,k;
262 
    int bit[64];
263 
    int newbit[64];
264 
    int kb[9][8];
265 
 
266 40 simon111 
    DEBUG_OUTPUT_ARR(CK,8);
267 
 
268 10 simon111 
    /*  56 steps */
269 
    /*  56 key bytes kk(56)..kk(1) by key schedule from CK */
270 
 
271 
    /*  kb(7,1) .. kb(7,8) = CK(1) .. CK(8) */
272 
    kb[7][1] = CK[0];
273 
    kb[7][2] = CK[1];
274 
    kb[7][3] = CK[2];
275 
    kb[7][4] = CK[3];
276 
    kb[7][5] = CK[4];
277 
    kb[7][6] = CK[5];
278 
    kb[7][7] = CK[6];
279 
    kb[7][8] = CK[7];
280 
 
281 
    /*  calculate kb[6] .. kb[1] */
282 
    for(i=0; i<7; i++) {
283 
        /*  64 bit perm on kb */
284 
        for(j=0; j<8; j++) {
285 
            for(k=0; k<8; k++) {
286 
                bit[j*8+k] = (kb[7-i][1+j] >> (7-k)) & 1;
287 
                newbit[key_perm[j*8+k]-1] = bit[j*8+k];
288 
            }
289 
        }
290 
        for(j=0; j<8; j++) {
291 
            kb[6-i][1+j] = 0;
292 
            for(k=0; k<8; k++) {
293 
                kb[6-i][1+j] |= newbit[j*8+k] << (7-k);
294 
            }
295 
        }
296 
    }
297 
 
298 
    /*  xor to give kk */
299 
    for(i=0; i<7; i++) {
300 
        for(j=0; j<8; j++) {
301 
            kk[1+i*8+j] = kb[1+i][1+j] ^ i;
302 
        }
303 
    }
304 
}
305 
 
306 
void block_decypher(int *kk, unsigned char *ib, unsigned char *bd) {
307 
    int i;
308 
    int sbox_in;
309 
    int sbox_out;
310 
    int perm_out;
311 
    int R[9];
312 
    int next_R8;
313 
 
314 
    R[1] = ib[0];
315 
    R[2] = ib[1];
316 
    R[3] = ib[2];
317 
    R[4] = ib[3];
318 
    R[5] = ib[4];
319 
    R[6] = ib[5];
320 
    R[7] = ib[6];
321 
    R[8] = ib[7];
322 
 
323 
    /*  loop over kk[56]..kk[1] */
324 
    for(i=56; i>0; i--) {
325 
        sbox_in = kk[i] ^ R[7];
326 
        sbox_out = block_sbox[sbox_in];
327 
        perm_out = block_perm[sbox_out];
328 
 
329 
        next_R8 = R[7];
330 
        R[7] = R[6] ^ perm_out;
331 
        R[6] = R[5];
332 
        R[5] = R[4] ^ R[8] ^ sbox_out;
333 
        R[4] = R[3] ^ R[8] ^ sbox_out;
334 
        R[3] = R[2] ^ R[8] ^ sbox_out;
335 
        R[2] = R[1];
336 
        R[1] = R[8] ^ sbox_out;
337 
 
338 
        R[8] = next_R8;
339 
    }
340 
 
341 
    bd[0] = R[1];
342 
    bd[1] = R[2];
343 
    bd[2] = R[3];
344 
    bd[3] = R[4];
345 
    bd[4] = R[5];
346 
    bd[5] = R[6];
347 
    bd[6] = R[7];
348 
    bd[7] = R[8];
349 
 
350 
}
351 
 
352 
void set_cws(unsigned char *cws, struct key *key) {
353 22 simon111 
        memcpy(key->odd_ck,cws+8,8);
354 
        memcpy(key->even_ck,cws,8);
355 
        key_schedule(key->odd_ck,key->odd_kk);
356 
        key_schedule(key->even_ck,key->even_kk);
357 40 simon111 
        DEBUG_OUTPUT_ARR(key->even_kk,57);
358 
        DEBUG_OUTPUT_ARR(key->odd_kk,57);
359 10 simon111 
}
360 
 
361 
void decrypt(struct key *key, unsigned char *encrypted, unsigned char *decrypted) {
362 
    int i,j,offset=4,N;
363 
    int *kk=key->even_kk;
364 
    unsigned char *ck=key->even_ck;
365 
    unsigned char stream[8];
366 
    unsigned char ib[8];
367 
    unsigned char block[8];
368 
    int residue;
369 
 
370 22 simon111 
        ((unsigned long *) decrypted)[0]=((unsigned long *) encrypted)[0];
371 
 
372 
        if(decrypted[3]&0x40) {
373 
                kk=key->odd_kk;
374 
                ck=key->odd_ck;
375 
        }
376 
 
377 10 simon111 
    decrypted[3] &= 0x3f;              /* remove scrambling bits */
378 22 simon111 
 
379 10 simon111 
    if ((decrypted[3] & 0x20) == 0x20)
380 
      offset += (encrypted[4] +1);               /* skip adaption field */
381 
 
382 
    N = (188 - offset) / 8;
383 
    residue = (188 - offset) % 8;
384 
 
385 
    /*  1st 8 bytes of initialisation */
386 
    stream_cypher(1, ck, &encrypted[offset], ib);
387 41 simon111 
    DEBUG_OUTPUT_ARR(ib,8);
388 10 simon111 
 
389 
    for(j=1; j<(N+1); j++) {
390 22 simon111 
                block_decypher(kk, ib, block);
391 10 simon111 
 
392 
        if (j != N) {
393 
            stream_cypher(0, ck, NULL, stream);
394 
 
395 
            /*  xor sb x stream */
396 
            for(i=0; i<8; i++)
397 
                ib[i] = encrypted[offset+8*j+i] ^ stream[i];
398 
        }
399 
        else {
400 
            /*  last block - sb[N+1] = IV(initialisation vetor)(=0) */
401 
            for(i=0; i<8; i++)  ib[i] = 0;
402 
        }
403 
 
404 
        /*  xor ib x block */
405 
        for(i=0; i<8; i++)
406 
                 decrypted[offset+8*(j-1)+i] = ib[i] ^ block[i];
407 
    } /* for(j=1; j<(N+1); j++) */
408 
 
409 
    if (residue) {
410 
       stream_cypher(0, ck, NULL, stream);
411 
       for (i=0;i<residue;i++)
412 
        decrypted[188-residue+i] = encrypted[188-residue+i] ^ stream[i];
413 
    }
414 
 
415 
}
416 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.