1 /*
2 * EAP server/peer: EAP-GPSK shared routines
3 * Copyright (c) 2006-2007, Jouni Malinen <j@w1.fi>
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "includes.h"
10
11 #include "common.h"
12 #include "crypto/aes_wrap.h"
13 #include "crypto/sha256.h"
14 #include "eap_defs.h"
15 #include "eap_gpsk_common.h"
16
17
18 /**
19 * eap_gpsk_supported_ciphersuite - Check whether ciphersuite is supported
20 * @vendor: CSuite/Vendor
21 * @specifier: CSuite/Specifier
22 * Returns: 1 if ciphersuite is support, or 0 if not
23 */
eap_gpsk_supported_ciphersuite(int vendor,int specifier)24 int eap_gpsk_supported_ciphersuite(int vendor, int specifier)
25 {
26 if (vendor == EAP_GPSK_VENDOR_IETF &&
27 specifier == EAP_GPSK_CIPHER_AES)
28 return 1;
29 #ifdef EAP_GPSK_SHA256
30 if (vendor == EAP_GPSK_VENDOR_IETF &&
31 specifier == EAP_GPSK_CIPHER_SHA256)
32 return 1;
33 #endif /* EAP_GPSK_SHA256 */
34 return 0;
35 }
36
37
eap_gpsk_gkdf_cmac(const u8 * psk,const u8 * data,size_t data_len,u8 * buf,size_t len)38 static int eap_gpsk_gkdf_cmac(const u8 *psk /* Y */,
39 const u8 *data /* Z */, size_t data_len,
40 u8 *buf, size_t len /* X */)
41 {
42 u8 *opos;
43 size_t i, n, hashlen, left, clen;
44 u8 ibuf[2], hash[16];
45 const u8 *addr[2];
46 size_t vlen[2];
47
48 hashlen = sizeof(hash);
49 /* M_i = MAC_Y (i || Z); (MAC = AES-CMAC-128) */
50 addr[0] = ibuf;
51 vlen[0] = sizeof(ibuf);
52 addr[1] = data;
53 vlen[1] = data_len;
54
55 opos = buf;
56 left = len;
57 n = (len + hashlen - 1) / hashlen;
58 for (i = 1; i <= n; i++) {
59 WPA_PUT_BE16(ibuf, i);
60 if (omac1_aes_128_vector(psk, 2, addr, vlen, hash))
61 return -1;
62 clen = left > hashlen ? hashlen : left;
63 os_memcpy(opos, hash, clen);
64 opos += clen;
65 left -= clen;
66 }
67
68 return 0;
69 }
70
71
72 #ifdef EAP_GPSK_SHA256
eap_gpsk_gkdf_sha256(const u8 * psk,const u8 * data,size_t data_len,u8 * buf,size_t len)73 static int eap_gpsk_gkdf_sha256(const u8 *psk /* Y */,
74 const u8 *data /* Z */, size_t data_len,
75 u8 *buf, size_t len /* X */)
76 {
77 u8 *opos;
78 size_t i, n, hashlen, left, clen;
79 u8 ibuf[2], hash[SHA256_MAC_LEN];
80 const u8 *addr[2];
81 size_t vlen[2];
82
83 hashlen = SHA256_MAC_LEN;
84 /* M_i = MAC_Y (i || Z); (MAC = HMAC-SHA256) */
85 addr[0] = ibuf;
86 vlen[0] = sizeof(ibuf);
87 addr[1] = data;
88 vlen[1] = data_len;
89
90 opos = buf;
91 left = len;
92 n = (len + hashlen - 1) / hashlen;
93 for (i = 1; i <= n; i++) {
94 WPA_PUT_BE16(ibuf, i);
95 hmac_sha256_vector(psk, 32, 2, addr, vlen, hash);
96 clen = left > hashlen ? hashlen : left;
97 os_memcpy(opos, hash, clen);
98 opos += clen;
99 left -= clen;
100 }
101
102 return 0;
103 }
104 #endif /* EAP_GPSK_SHA256 */
105
106
eap_gpsk_derive_keys_helper(u32 csuite_specifier,u8 * kdf_out,size_t kdf_out_len,const u8 * psk,size_t psk_len,const u8 * seed,size_t seed_len,u8 * msk,u8 * emsk,u8 * sk,size_t sk_len,u8 * pk,size_t pk_len)107 static int eap_gpsk_derive_keys_helper(u32 csuite_specifier,
108 u8 *kdf_out, size_t kdf_out_len,
109 const u8 *psk, size_t psk_len,
110 const u8 *seed, size_t seed_len,
111 u8 *msk, u8 *emsk,
112 u8 *sk, size_t sk_len,
113 u8 *pk, size_t pk_len)
114 {
115 u8 mk[32], *pos, *data;
116 size_t data_len, mk_len;
117 int (*gkdf)(const u8 *_psk, const u8 *_data, size_t _data_len,
118 u8 *buf, size_t len);
119
120 gkdf = NULL;
121 switch (csuite_specifier) {
122 case EAP_GPSK_CIPHER_AES:
123 gkdf = eap_gpsk_gkdf_cmac;
124 mk_len = 16;
125 break;
126 #ifdef EAP_GPSK_SHA256
127 case EAP_GPSK_CIPHER_SHA256:
128 gkdf = eap_gpsk_gkdf_sha256;
129 mk_len = SHA256_MAC_LEN;
130 break;
131 #endif /* EAP_GPSK_SHA256 */
132 default:
133 return -1;
134 }
135
136 if (psk_len < mk_len)
137 return -1;
138
139 data_len = 2 + psk_len + 6 + seed_len;
140 data = os_malloc(data_len);
141 if (data == NULL)
142 return -1;
143 pos = data;
144 WPA_PUT_BE16(pos, psk_len);
145 pos += 2;
146 os_memcpy(pos, psk, psk_len);
147 pos += psk_len;
148 WPA_PUT_BE32(pos, EAP_GPSK_VENDOR_IETF); /* CSuite/Vendor = IETF */
149 pos += 4;
150 WPA_PUT_BE16(pos, csuite_specifier); /* CSuite/Specifier */
151 pos += 2;
152 os_memcpy(pos, seed, seed_len); /* inputString */
153 wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: Data to MK derivation",
154 data, data_len);
155
156 if (gkdf(psk, data, data_len, mk, mk_len) < 0) {
157 os_free(data);
158 return -1;
159 }
160 os_free(data);
161 wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: MK", mk, mk_len);
162
163 if (gkdf(mk, seed, seed_len, kdf_out, kdf_out_len) < 0)
164 return -1;
165
166 pos = kdf_out;
167 wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: MSK", pos, EAP_MSK_LEN);
168 os_memcpy(msk, pos, EAP_MSK_LEN);
169 pos += EAP_MSK_LEN;
170
171 wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: EMSK", pos, EAP_EMSK_LEN);
172 os_memcpy(emsk, pos, EAP_EMSK_LEN);
173 pos += EAP_EMSK_LEN;
174
175 wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: SK", pos, sk_len);
176 os_memcpy(sk, pos, sk_len);
177 pos += sk_len;
178
179 if (pk) {
180 wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: PK", pos, pk_len);
181 os_memcpy(pk, pos, pk_len);
182 }
183
184 return 0;
185 }
186
187
eap_gpsk_derive_keys_aes(const u8 * psk,size_t psk_len,const u8 * seed,size_t seed_len,u8 * msk,u8 * emsk,u8 * sk,size_t * sk_len,u8 * pk,size_t * pk_len)188 static int eap_gpsk_derive_keys_aes(const u8 *psk, size_t psk_len,
189 const u8 *seed, size_t seed_len,
190 u8 *msk, u8 *emsk, u8 *sk, size_t *sk_len,
191 u8 *pk, size_t *pk_len)
192 {
193 #define EAP_GPSK_SK_LEN_AES 16
194 #define EAP_GPSK_PK_LEN_AES 16
195 u8 kdf_out[EAP_MSK_LEN + EAP_EMSK_LEN + EAP_GPSK_SK_LEN_AES +
196 EAP_GPSK_PK_LEN_AES];
197
198 /*
199 * inputString = RAND_Peer || ID_Peer || RAND_Server || ID_Server
200 * (= seed)
201 * KS = 16, PL = psk_len, CSuite_Sel = 0x00000000 0x0001
202 * MK = GKDF-16 (PSK[0..15], PL || PSK || CSuite_Sel || inputString)
203 * MSK = GKDF-160 (MK, inputString)[0..63]
204 * EMSK = GKDF-160 (MK, inputString)[64..127]
205 * SK = GKDF-160 (MK, inputString)[128..143]
206 * PK = GKDF-160 (MK, inputString)[144..159]
207 * zero = 0x00 || 0x00 || ... || 0x00 (16 times)
208 * Method-ID = GKDF-16 (zero, "Method ID" || EAP_Method_Type ||
209 * CSuite_Sel || inputString)
210 */
211
212 *sk_len = EAP_GPSK_SK_LEN_AES;
213 *pk_len = EAP_GPSK_PK_LEN_AES;
214
215 return eap_gpsk_derive_keys_helper(EAP_GPSK_CIPHER_AES,
216 kdf_out, sizeof(kdf_out),
217 psk, psk_len, seed, seed_len,
218 msk, emsk, sk, *sk_len,
219 pk, *pk_len);
220 }
221
222
223 #ifdef EAP_GPSK_SHA256
eap_gpsk_derive_keys_sha256(const u8 * psk,size_t psk_len,const u8 * seed,size_t seed_len,u8 * msk,u8 * emsk,u8 * sk,size_t * sk_len)224 static int eap_gpsk_derive_keys_sha256(const u8 *psk, size_t psk_len,
225 const u8 *seed, size_t seed_len,
226 u8 *msk, u8 *emsk,
227 u8 *sk, size_t *sk_len)
228 {
229 #define EAP_GPSK_SK_LEN_SHA256 SHA256_MAC_LEN
230 #define EAP_GPSK_PK_LEN_SHA256 SHA256_MAC_LEN
231 u8 kdf_out[EAP_MSK_LEN + EAP_EMSK_LEN + EAP_GPSK_SK_LEN_SHA256 +
232 EAP_GPSK_PK_LEN_SHA256];
233
234 /*
235 * inputString = RAND_Peer || ID_Peer || RAND_Server || ID_Server
236 * (= seed)
237 * KS = 32, PL = psk_len, CSuite_Sel = 0x00000000 0x0002
238 * MK = GKDF-32 (PSK[0..31], PL || PSK || CSuite_Sel || inputString)
239 * MSK = GKDF-160 (MK, inputString)[0..63]
240 * EMSK = GKDF-160 (MK, inputString)[64..127]
241 * SK = GKDF-160 (MK, inputString)[128..159]
242 * zero = 0x00 || 0x00 || ... || 0x00 (32 times)
243 * Method-ID = GKDF-16 (zero, "Method ID" || EAP_Method_Type ||
244 * CSuite_Sel || inputString)
245 */
246
247 *sk_len = EAP_GPSK_SK_LEN_SHA256;
248
249 return eap_gpsk_derive_keys_helper(EAP_GPSK_CIPHER_SHA256,
250 kdf_out, sizeof(kdf_out),
251 psk, psk_len, seed, seed_len,
252 msk, emsk, sk, *sk_len,
253 NULL, 0);
254 }
255 #endif /* EAP_GPSK_SHA256 */
256
257
258 /**
259 * eap_gpsk_derive_keys - Derive EAP-GPSK keys
260 * @psk: Pre-shared key
261 * @psk_len: Length of psk in bytes
262 * @vendor: CSuite/Vendor
263 * @specifier: CSuite/Specifier
264 * @rand_peer: 32-byte RAND_Peer
265 * @rand_server: 32-byte RAND_Server
266 * @id_peer: ID_Peer
267 * @id_peer_len: Length of ID_Peer
268 * @id_server: ID_Server
269 * @id_server_len: Length of ID_Server
270 * @msk: Buffer for 64-byte MSK
271 * @emsk: Buffer for 64-byte EMSK
272 * @sk: Buffer for SK (at least EAP_GPSK_MAX_SK_LEN bytes)
273 * @sk_len: Buffer for returning length of SK
274 * @pk: Buffer for PK (at least EAP_GPSK_MAX_PK_LEN bytes)
275 * @pk_len: Buffer for returning length of PK
276 * Returns: 0 on success, -1 on failure
277 */
eap_gpsk_derive_keys(const u8 * psk,size_t psk_len,int vendor,int specifier,const u8 * rand_peer,const u8 * rand_server,const u8 * id_peer,size_t id_peer_len,const u8 * id_server,size_t id_server_len,u8 * msk,u8 * emsk,u8 * sk,size_t * sk_len,u8 * pk,size_t * pk_len)278 int eap_gpsk_derive_keys(const u8 *psk, size_t psk_len, int vendor,
279 int specifier,
280 const u8 *rand_peer, const u8 *rand_server,
281 const u8 *id_peer, size_t id_peer_len,
282 const u8 *id_server, size_t id_server_len,
283 u8 *msk, u8 *emsk, u8 *sk, size_t *sk_len,
284 u8 *pk, size_t *pk_len)
285 {
286 u8 *seed, *pos;
287 size_t seed_len;
288 int ret;
289
290 wpa_printf(MSG_DEBUG, "EAP-GPSK: Deriving keys (%d:%d)",
291 vendor, specifier);
292
293 if (vendor != EAP_GPSK_VENDOR_IETF)
294 return -1;
295
296 wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: PSK", psk, psk_len);
297
298 /* Seed = RAND_Peer || ID_Peer || RAND_Server || ID_Server */
299 seed_len = 2 * EAP_GPSK_RAND_LEN + id_server_len + id_peer_len;
300 seed = os_malloc(seed_len);
301 if (seed == NULL) {
302 wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to allocate memory "
303 "for key derivation");
304 return -1;
305 }
306
307 pos = seed;
308 os_memcpy(pos, rand_peer, EAP_GPSK_RAND_LEN);
309 pos += EAP_GPSK_RAND_LEN;
310 os_memcpy(pos, id_peer, id_peer_len);
311 pos += id_peer_len;
312 os_memcpy(pos, rand_server, EAP_GPSK_RAND_LEN);
313 pos += EAP_GPSK_RAND_LEN;
314 os_memcpy(pos, id_server, id_server_len);
315 pos += id_server_len;
316 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Seed", seed, seed_len);
317
318 switch (specifier) {
319 case EAP_GPSK_CIPHER_AES:
320 ret = eap_gpsk_derive_keys_aes(psk, psk_len, seed, seed_len,
321 msk, emsk, sk, sk_len,
322 pk, pk_len);
323 break;
324 #ifdef EAP_GPSK_SHA256
325 case EAP_GPSK_CIPHER_SHA256:
326 ret = eap_gpsk_derive_keys_sha256(psk, psk_len, seed, seed_len,
327 msk, emsk, sk, sk_len);
328 break;
329 #endif /* EAP_GPSK_SHA256 */
330 default:
331 wpa_printf(MSG_DEBUG, "EAP-GPSK: Unknown cipher %d:%d used in "
332 "key derivation", vendor, specifier);
333 ret = -1;
334 break;
335 }
336
337 os_free(seed);
338
339 return ret;
340 }
341
342
eap_gpsk_derive_mid_helper(u32 csuite_specifier,u8 * kdf_out,size_t kdf_out_len,const u8 * psk,const u8 * seed,size_t seed_len,u8 method_type)343 static int eap_gpsk_derive_mid_helper(u32 csuite_specifier,
344 u8 *kdf_out, size_t kdf_out_len,
345 const u8 *psk, const u8 *seed,
346 size_t seed_len, u8 method_type)
347 {
348 u8 *pos, *data;
349 size_t data_len;
350 int (*gkdf)(const u8 *_psk, const u8 *_data, size_t _data_len,
351 u8 *buf, size_t len);
352
353 gkdf = NULL;
354 switch (csuite_specifier) {
355 case EAP_GPSK_CIPHER_AES:
356 gkdf = eap_gpsk_gkdf_cmac;
357 break;
358 #ifdef EAP_GPSK_SHA256
359 case EAP_GPSK_CIPHER_SHA256:
360 gkdf = eap_gpsk_gkdf_sha256;
361 break;
362 #endif /* EAP_GPSK_SHA256 */
363 default:
364 wpa_printf(MSG_DEBUG, "EAP-GPSK: Unknown cipher %d used in "
365 "Session-Id derivation", csuite_specifier);
366 return -1;
367 }
368
369 #define SID_LABEL "Method ID"
370 /* "Method ID" || EAP_Method_Type || CSuite_Sel || inputString */
371 data_len = strlen(SID_LABEL) + 1 + 6 + seed_len;
372 data = os_malloc(data_len);
373 if (data == NULL)
374 return -1;
375 pos = data;
376 os_memcpy(pos, SID_LABEL, strlen(SID_LABEL));
377 pos += strlen(SID_LABEL);
378 #undef SID_LABEL
379 os_memcpy(pos, &method_type, 1);
380 pos += 1;
381 WPA_PUT_BE32(pos, EAP_GPSK_VENDOR_IETF); /* CSuite/Vendor = IETF */
382 pos += 4;
383 WPA_PUT_BE16(pos, csuite_specifier); /* CSuite/Specifier */
384 pos += 2;
385 os_memcpy(pos, seed, seed_len); /* inputString */
386 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Data to Method ID derivation",
387 data, data_len);
388
389 if (gkdf(psk, data, data_len, kdf_out, kdf_out_len) < 0) {
390 os_free(data);
391 return -1;
392 }
393 os_free(data);
394 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Method ID", kdf_out, kdf_out_len);
395
396 return 0;
397 }
398
399
400 /**
401 * eap_gpsk_session_id - Derive EAP-GPSK Session ID
402 * @psk: Pre-shared key
403 * @psk_len: Length of psk in bytes
404 * @vendor: CSuite/Vendor
405 * @specifier: CSuite/Specifier
406 * @rand_peer: 32-byte RAND_Peer
407 * @rand_server: 32-byte RAND_Server
408 * @id_peer: ID_Peer
409 * @id_peer_len: Length of ID_Peer
410 * @id_server: ID_Server
411 * @id_server_len: Length of ID_Server
412 * @method_type: EAP Authentication Method Type
413 * @sid: Buffer for 17-byte Session ID
414 * @sid_len: Buffer for returning length of Session ID
415 * Returns: 0 on success, -1 on failure
416 */
eap_gpsk_derive_session_id(const u8 * psk,size_t psk_len,int vendor,int specifier,const u8 * rand_peer,const u8 * rand_server,const u8 * id_peer,size_t id_peer_len,const u8 * id_server,size_t id_server_len,u8 method_type,u8 * sid,size_t * sid_len)417 int eap_gpsk_derive_session_id(const u8 *psk, size_t psk_len, int vendor,
418 int specifier,
419 const u8 *rand_peer, const u8 *rand_server,
420 const u8 *id_peer, size_t id_peer_len,
421 const u8 *id_server, size_t id_server_len,
422 u8 method_type, u8 *sid, size_t *sid_len)
423 {
424 u8 *seed, *pos;
425 u8 kdf_out[16];
426 size_t seed_len;
427 int ret;
428
429 wpa_printf(MSG_DEBUG, "EAP-GPSK: Deriving Session ID(%d:%d)",
430 vendor, specifier);
431
432 if (vendor != EAP_GPSK_VENDOR_IETF)
433 return -1;
434
435 wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: PSK", psk, psk_len);
436
437 /*
438 * inputString = RAND_Peer || ID_Peer || RAND_Server || ID_Server
439 * (= seed)
440 * KS = 16, CSuite_Sel = 0x00000000 0x0001
441 * Method-ID = GKDF-16 (zero, "Method ID" || EAP_Method_Type ||
442 * CSuite_Sel || inputString)
443 */
444 seed_len = 2 * EAP_GPSK_RAND_LEN + id_server_len + id_peer_len;
445 seed = os_malloc(seed_len);
446 if (seed == NULL) {
447 wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to allocate memory "
448 "for Session-Id derivation");
449 return -1;
450 }
451
452 pos = seed;
453 os_memcpy(pos, rand_peer, EAP_GPSK_RAND_LEN);
454 pos += EAP_GPSK_RAND_LEN;
455 os_memcpy(pos, id_peer, id_peer_len);
456 pos += id_peer_len;
457 os_memcpy(pos, rand_server, EAP_GPSK_RAND_LEN);
458 pos += EAP_GPSK_RAND_LEN;
459 os_memcpy(pos, id_server, id_server_len);
460 pos += id_server_len;
461 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Seed", seed, seed_len);
462
463 ret = eap_gpsk_derive_mid_helper(specifier,
464 kdf_out, sizeof(kdf_out),
465 psk, seed, seed_len,
466 method_type);
467
468 sid[0] = method_type;
469 os_memcpy(sid + 1, kdf_out, sizeof(kdf_out));
470 *sid_len = 1 + sizeof(kdf_out);
471
472 os_free(seed);
473
474 return ret;
475 }
476
477
478 /**
479 * eap_gpsk_mic_len - Get the length of the MIC
480 * @vendor: CSuite/Vendor
481 * @specifier: CSuite/Specifier
482 * Returns: MIC length in bytes
483 */
eap_gpsk_mic_len(int vendor,int specifier)484 size_t eap_gpsk_mic_len(int vendor, int specifier)
485 {
486 if (vendor != EAP_GPSK_VENDOR_IETF)
487 return 0;
488
489 switch (specifier) {
490 case EAP_GPSK_CIPHER_AES:
491 return 16;
492 #ifdef EAP_GPSK_SHA256
493 case EAP_GPSK_CIPHER_SHA256:
494 return 32;
495 #endif /* EAP_GPSK_SHA256 */
496 default:
497 return 0;
498 }
499 }
500
501
eap_gpsk_compute_mic_aes(const u8 * sk,size_t sk_len,const u8 * data,size_t len,u8 * mic)502 static int eap_gpsk_compute_mic_aes(const u8 *sk, size_t sk_len,
503 const u8 *data, size_t len, u8 *mic)
504 {
505 if (sk_len != 16) {
506 wpa_printf(MSG_DEBUG, "EAP-GPSK: Invalid SK length %lu for "
507 "AES-CMAC MIC", (unsigned long) sk_len);
508 return -1;
509 }
510
511 return omac1_aes_128(sk, data, len, mic);
512 }
513
514
515 /**
516 * eap_gpsk_compute_mic - Compute EAP-GPSK MIC for an EAP packet
517 * @sk: Session key SK from eap_gpsk_derive_keys()
518 * @sk_len: SK length in bytes from eap_gpsk_derive_keys()
519 * @vendor: CSuite/Vendor
520 * @specifier: CSuite/Specifier
521 * @data: Input data to MIC
522 * @len: Input data length in bytes
523 * @mic: Buffer for the computed MIC, eap_gpsk_mic_len(cipher) bytes
524 * Returns: 0 on success, -1 on failure
525 */
eap_gpsk_compute_mic(const u8 * sk,size_t sk_len,int vendor,int specifier,const u8 * data,size_t len,u8 * mic)526 int eap_gpsk_compute_mic(const u8 *sk, size_t sk_len, int vendor,
527 int specifier, const u8 *data, size_t len, u8 *mic)
528 {
529 int ret;
530
531 if (vendor != EAP_GPSK_VENDOR_IETF)
532 return -1;
533
534 switch (specifier) {
535 case EAP_GPSK_CIPHER_AES:
536 ret = eap_gpsk_compute_mic_aes(sk, sk_len, data, len, mic);
537 break;
538 #ifdef EAP_GPSK_SHA256
539 case EAP_GPSK_CIPHER_SHA256:
540 hmac_sha256(sk, sk_len, data, len, mic);
541 ret = 0;
542 break;
543 #endif /* EAP_GPSK_SHA256 */
544 default:
545 wpa_printf(MSG_DEBUG, "EAP-GPSK: Unknown cipher %d:%d used in "
546 "MIC computation", vendor, specifier);
547 ret = -1;
548 break;
549 }
550
551 return ret;
552 }
553