Un programme pour déchiffrement Ascii to Hex et la suite non reconnu !

Bonjour tout le monde !
Je suis en étude d'un programme algorithmique codé sous C

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
 
#include <stdio.h>
#include <string.h>
 
void ASCII2HEX (unsigned char *origen, unsigned char *destino, int caracteres);
unsigned char convertir_byte_a_hex (unsigned char byte);
unsigned char calculo4_a (char caracter);
void calculo4 (unsigned char *cadena);
void calculo3 (unsigned char *cadena);
void calculo2_a (unsigned char *cadena, unsigned char byte, unsigned char byte2);
void calculo2 (unsigned char *cadena, unsigned char byte, unsigned char byte2);
void calculo1 (unsigned char byte, unsigned char *network_code_h, unsigned char *imei_h);
void calculo1_a (unsigned char *cadena);
void calcular_dct3 (unsigned char *imei, unsigned char *network_code, unsigned char *destino);
 
void ASCII2HEX (unsigned char *origen, unsigned char *destino, int caracteres)
{
        int i, j;
        unsigned char aux1, aux2;
 
        j=0;
        for(i=0; i<caracteres; i+=2)
        {
                aux1 = convertir_byte_a_hex(origen[i])<<4;
                if (i+1 < caracteres)
            aux2 = convertir_byte_a_hex(origen[i+1]);
                else
                        aux2 = 0;
                destino[j] = aux1 | aux2;
                j++;
        }
}
 
unsigned char convertir_byte_a_hex (unsigned char byte)
{
        if ((byte > 57) || (byte < 48))  // '0' a '9'
                return (byte-55);
        else
                return (byte-48);        // 'A' a 'F' o otro caracter
}
 
unsigned char calculo4_a (char caracter)
{
        unsigned char aux1, aux2, aux3, temp;
        int i;
 
        aux1=0;
        aux2=7;
        temp=0;
 
        for (i=0; i<8; i++)
        {
                aux3=caracter;
                aux3=aux3>>aux2;
                aux3&=1;
                aux3=aux3<<aux1;
                temp|=aux3;
                aux1++;
                aux2--;
        }
        return temp;
}
 
void calculo4 (unsigned char *cadena)
{
        char temp[12];
        int i;
 
        memcpy(temp, cadena, 12);
 
        for (i=0; i<12; i++)
        {
                cadena[11-i]=calculo4_a(temp[i]);
        }
 
}
void permu1(unsigned char *network_code_hex, unsigned char *tabla, unsigned char *imei_hex)
{       
        unsigned char *puntero;
        int i;
 
        puntero=tabla;
 
        for (i=0; i<11; i++) {
                calculo1(*puntero, network_code_hex, imei_hex);
                calculo2(network_code_hex, 0, 8);
                calculo3(network_code_hex);
                calculo2(network_code_hex, 8, 0);
                puntero++;
        }
 
        calculo1(tabla[11], network_code_hex, imei_hex);
        calculo4(network_code_hex);
}
void calculo3 (unsigned char *cadena)
{
        unsigned char aux1, aux2, aux3, temp1, temp2;
        char temp[12];
        int i;
 
        memcpy(temp, cadena, 12);
        temp2=12;
        temp1=7;
        aux1=3;
 
        for(i=0; i<12; i++)
        {
                aux2=temp1;
                aux3=aux1;
                aux2=temp[aux2];
                aux2^=0xFF;
                aux2|=temp[aux3];
                temp2--;
 
                if (temp1==0)
                        temp1=12;
 
                temp1--;
 
                if (aux1==0)
                        aux1+=12;
 
                aux3=temp2;
                cadena[aux3]^=aux2;
 
                aux1--;
        }
}
 
void calculo2_a (unsigned char *cadena, unsigned char byte, unsigned char byte2)
{
        unsigned char aux1, aux2, aux3;
        unsigned char *puntero;
        int i,j;
 
        if (byte==0)
                return;
 
        for (i=0; i<byte; i++) 
        {
                aux1=cadena[byte2+3];
                aux1&=1;
                puntero=cadena+byte2;
 
                for (j=0; j<4; j++)
                {
                        aux2=*puntero;
                        aux3=aux2;
                        aux2=aux2>>1;
                        aux1=aux1<<7;
                        aux2|=aux1;
                        aux3&=1;
                        *puntero=aux2;
                        aux1=aux3;
                        puntero++;
                }
        }
}
 
void calculo2 (unsigned char *cadena, unsigned char byte, unsigned char byte2)
{
    calculo2_a(cadena, 10, byte);
        calculo2_a(cadena, 31, byte2);
}
 
void calculo1 (unsigned char byte, unsigned char *network_code_h, unsigned char *imei_h)
{
        unsigned char aux1, aux2;
        int contador;
        unsigned char *puntero, *puntero2;
 
        puntero=network_code_h;
        puntero2=imei_h;
        contador=0;
        aux1=0;
 
        while (contador < 12)
        {
                aux2=aux1;
                aux2=(aux2>>1) % 3;
                aux2&=1;
                aux2*=byte;
                aux2^=(*puntero2);
                (*puntero)^=aux2;
                aux1++;
                puntero++;
                puntero2++;
 
                contador++;
        }
        calculo1_a(network_code_h);
}
 
void calculo1_a (unsigned char *cadena)
{
        // 60 bytes
        char tabla1[] = {0x01,0x09,0x04,0x08,0x0B,0x05,0x09,0x08,0x06,0x0A, \
                         0x01,0x03,0x0B,0x06,0x0A,0x00,0x08,0x07,0x0B,0x0A, \
                         0x01,0x05,0x00,0x08,0x03,0x01,0x09,0x00,0x02,0x0A, \
                         0x05,0x03,0x07,0x02,0x0A,0x00,0x04,0x03,0x0B,0x02, \
                         0x05,0x09,0x00,0x04,0x07,0x01,0x05,0x04,0x02,0x06, \
                         0x09,0x07,0x0B,0x02,0x06,0x04,0x08,0x03,0x07,0x06};
 
        // 60 bytes
        char tabla2[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, \
                         0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x01, \
                         0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x01, \
                         0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01, \
                         0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01, \
                         0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01};
 
        unsigned char *puntero=cadena;
        unsigned char aux1, aux2;
        int contador1, contador2, contador3;
        char variable_8c[12];
 
        contador1=0;
        aux1=0;
        aux2=0;
 
        while (contador1<12) {
                contador2=5;
                aux2^=*puntero;
 
                while (contador2>0) {
                        if ((tabla2[aux1] == 0) && (contador1 <6)) {
                                variable_8c[tabla1[aux1]]=*puntero;
                        }
                        else {
                                variable_8c[tabla1[aux1]]^=*puntero;
                        }
                        aux1++;
                        contador2--;
                }
                contador1++;
                puntero++;
        }
 
        for (contador3=0; contador3<12; contador3++)
                variable_8c[contador3]^=aux2;
 
        memcpy(cadena, variable_8c, 12);        
}
 
void calcular_dct3 (unsigned char *imei, unsigned char *network_code, unsigned char *destino)
{
        char tabla[] = {0xb1,0x73,0xe6,0x5a,0xab,0x47,0x8e,0x0d,0x1a,0x34,0x68,0x0b}; //12 bytes
        char network_code_h[12], imei_h[12];
        int i, j;
        unsigned char aux1;
 
        memset(network_code_h, 0, sizeof(network_code_h));
        memset(imei_h, 0, sizeof(imei_h));
        ASCII2HEX(network_code, network_code_h, (int)strlen(network_code));
        ASCII2HEX(imei, imei_h+2, 14);
 
        for (i=2; i<12; i++)
                imei_h[i]^=0xa5;
 
        permu1(network_code_h, tabla, imei_h);
 
	j=0;
        for (i=0; i<5; i++)
        {
                aux1=network_code_h[i];
                if ((aux1&0x80) == 0x80)
                        aux1+=0xa0;
                if ((aux1&0x08) == 0x08)
            		aux1+=0xfa;
 
		destino[j]=(aux1 >> 4) + 0x30;
		j++;
		destino[j]=(aux1 & 0x0F) + 0x30;
		j++;
        }
        destino[j]=0;
}
void main() 
{
        // examples - ejemplos
 
        char destino[11];
 
        calcular_dct3 ( "111111111111119", "22222", destino);  // Code1 use network code
        printf("#pw+%s+1#\n", destino);                        // Codigo1 usar el codigo de operador
 
        calcular_dct3 ( "111111111111119", "FFFF", destino);   // Code2 use GID1
        printf("#pw+%s+2#\n", destino);                        // Codigo2 usar el GID1
}

Jusqu'as ici :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
{
        int i, j;
        unsigned char aux1, aux2;
 
        j=0;
        for(i=0; i<caracteres; i+=2)
        {
                aux1 = convertir_byte_a_hex(origen[i])<<4;
                if (i+1 < caracteres)
            aux2 = convertir_byte_a_hex(origen[i+1]);
                else
                        aux2 = 0;
                destino[j] = aux1 | aux2;
                j++;
        }
}
 
unsigned char convertir_byte_a_hex (unsigned char byte)
{
        if ((byte > 57) || (byte < 48))  // '0' a '9'
                return (byte-55);
        else
                return (byte-48);        // 'A' a 'F' o otro caracter
}
 
unsigned char calculo4_a (char caracter)
{
        unsigned char aux1, aux2, aux3, temp;
        int i;
 
        aux1=0;
        aux2=7;
        temp=0;
 
        for (i=0; i<8; i++)
        {
                aux3=caracter;
                aux3=aux3>>aux2;
                aux3&=1;
                aux3=aux3<<aux1;
                temp|=aux3;
                aux1++;
                aux2--;
        }
        return temp;
}
 
void calculo4 (unsigned char *cadena)
{
        char temp[12];
        int i;
 
        memcpy(temp, cadena, 12);
 
        for (i=0; i<12; i++)
        {
                cadena[11-i]=calculo4_a(temp[i]);
        }
 
}

je comprend que c'est pour convertir depuis un Code ASCII qui contient 8 bits ( si je ne me trompe pas ) vers un code Hexadécimale qui contient 32 bite la colonne .

Mais apres cela je suis perdu quelqu'un pourai me dire quesqu'il fait la suite du programme ?

:(

Commence par indenter.

Etant donné que ton code, c'est du C, il a été déplacé dans le forum C (malgré le fait que tu dises que c'est du C++..; hum)

Je te propose le code suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
#include <ctype.h>
 
static char convert_hex2asc_tab[16] = "0123456789abcdef";
 
int
convert_hex2asc(char *dest, const char *src, size_t size) {
    size_t i;
 
    for (i = 0; i < size; i++) {
	unsigned char c = src[i];
 
	dest[2 * i] = convert_hex2asc_tab[(c >> 4) & 0xf];
	dest[2 * i + 1] = convert_hex2asc_tab[c & 0xf];
    }
 
    return 0;		
}
 
static int
convert_xdigit2asc(unsigned char c) {
    if (!isxdigit(c))
	return -1;
 
    if (c >= '0' && c <= '9')
	return c - '0';
 
    return toupper(c) - 'A' + 10;
}
 
int
convert_asc2hex(char *dest, const char *src, size_t size) {
    size_t i;
    size_t j;
 
    if ((size % 2) != 0)
	return 1;
 
    for (i = 0, j = 0; i < size; i += 2, j++) {
	int half1;
	int half2;
 
	half1 = convert_xdigit2asc((unsigned char) (src[i]));
	if (half1 == -1)
	    return 1;
	half2 = convert_xdigit2asc((unsigned char) (src[i + 1]));
	if (half2 == -1)
	    return 1;
 
	dest[j] = (half1 << 4) | half2;
    }
 
    return 0;
}
 
 
/** 
 * 
 * 
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int
main(void) {
    char ascbuf[] = "cafebabe1337deadbeef";
    char hexbuf[sizeof ascbuf / 2];
    char ascbuf2[sizeof ascbuf];
 
    printf("orig ascbuf: %s\n", ascbuf);
 
    if (convert_asc2hex(hexbuf, ascbuf, sizeof ascbuf - 1)) {
	printf("*** convert_asc2hex() failed!\n");
	return EXIT_FAILURE;
    }
 
    if (convert_hex2asc(ascbuf2, hexbuf, sizeof hexbuf)) {
	printf("*** convert_hex2asc() failed!\n");
	return EXIT_FAILURE;
    }
    ascbuf2[sizeof ascbuf2 - 1] = '\0';
    printf("ascbuf2: %s\n", ascbuf2);
 
    if (strcmp(ascbuf, ascbuf2)) {
	printf("*** ascbuf's differ! TEST FAILED\n");
	return EXIT_FAILURE;
    }
 
    return EXIT_SUCCESS;
}

et si tu es sur *n*x :

la commande od :P

(je crois bien, si mes souvenirs sont bons)

merci millie pour ton desieme code .

Mais c'est quoi exactement , je pense que c'est le meme Que le mien .?

Sinon Est ce que tu peut suivre la desieme Etape sur le programme

Apres la conversation

Quesqu'il fait ?.

Merci

Et dsl je l'es mis sur la rebrique C++
:king: