← Back to branch summary

~cyphermox/ubuntu/lucid/wpasupplicant/dbus-pkcs11-eapol

« back to all changes in this revision

Viewing changes to crypto_gnutls.c

  • Committer: Bazaar Package Importer
  • Author(s): Kel Modderman
  • Date: 2006-10-05 08:04:01 UTC
  • mfrom: (1.2.1 upstream) (2.1.14 edgy)
  • Revision ID: james.westby@ubuntu.com-20061005080401-myfwjtq7di70dyeo
http://bugs.debian.org/388316
* Update madwifi headers to latest SVN. (Closes: #388316)
* Remove failed attempt at action locking. [debian/functions.sh,
  debian/wpa_action.sh]
* Add hysteresis checking functions, to avoid "event loops" while
  using wpa-roam. [debian/functions.sh, debian/wpa_action.sh]
* Change of co-maintainer email address.
* Add ishex() function to functions.sh to determine wpa-psk value type in
  plaintext or hex. This effectively eliminates the need for the bogus and
  somewhat confusing wpa-passphrase contruct specific to our scripts and
  allows wpa-psk to work with either a 8 to 63 character long plaintext
  string or 64 character long hex string.
* Adjust README.modes to not refer to the redundant wpa-passphrase stuff.
* Add big fat NOTE about acceptable wpa-psk's to top of example gallery.
* Strip surrounding quotes from wpa-ssid if present, instead of just whining
  about them.
* Update email address in copyright blurb of functions.sh, ifupdown.sh and
  wpa_action.sh.  

Show diffs side-by-side

added added

removed removed

Lines of Context:
crypto_gnutls.c
 
1
/*
 
2
 * WPA Supplicant / wrapper functions for libgcrypt
 
3
 * Copyright (c) 2004-2005, Jouni Malinen <jkmaline@cc.hut.fi>
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License version 2 as
 
7
 * published by the Free Software Foundation.
 
8
 *
 
9
 * Alternatively, this software may be distributed under the terms of BSD
 
10
 * license.
 
11
 *
 
12
 * See README and COPYING for more details.
 
13
 */
 
14
 
 
15
#include "includes.h"
 
16
#include <gcrypt.h>
 
17
 
 
18
#include "common.h"
 
19
#include "crypto.h"
 
20
 
 
21
void md4_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
 
22
{
 
23
        gcry_md_hd_t hd;
 
24
        unsigned char *p;
 
25
        size_t i;
 
26
 
 
27
        if (gcry_md_open(&hd, GCRY_MD_MD4, 0) != GPG_ERR_NO_ERROR)
 
28
                return;
 
29
        for (i = 0; i < num_elem; i++)
 
30
                gcry_md_write(hd, addr[i], len[i]);
 
31
        p = gcry_md_read(hd, GCRY_MD_MD4);
 
32
        if (p)
 
33
                memcpy(mac, p, gcry_md_get_algo_dlen(GCRY_MD_MD4));
 
34
        gcry_md_close(hd);
 
35
}
 
36
 
 
37
 
 
38
void des_encrypt(const u8 *clear, const u8 *key, u8 *cypher)
 
39
{
 
40
        gcry_cipher_hd_t hd;
 
41
        u8 pkey[8], next, tmp;
 
42
        int i;
 
43
 
 
44
        /* Add parity bits to the key */
 
45
        next = 0;
 
46
        for (i = 0; i < 7; i++) {
 
47
                tmp = key[i];
 
48
                pkey[i] = (tmp >> i) | next | 1;
 
49
                next = tmp << (7 - i);
 
50
        }
 
51
        pkey[i] = next | 1;
 
52
 
 
53
        gcry_cipher_open(&hd, GCRY_CIPHER_DES, GCRY_CIPHER_MODE_ECB, 0);
 
54
        gcry_err_code(gcry_cipher_setkey(hd, pkey, 8));
 
55
        gcry_cipher_encrypt(hd, cypher, 8, clear, 8);
 
56
        gcry_cipher_close(hd);
 
57
}
 
58
 
 
59
 
 
60
#ifdef EAP_TLS_FUNCS
 
61
void md5_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
 
62
{
 
63
        gcry_md_hd_t hd;
 
64
        unsigned char *p;
 
65
        size_t i;
 
66
 
 
67
        if (gcry_md_open(&hd, GCRY_MD_MD5, 0) != GPG_ERR_NO_ERROR)
 
68
                return;
 
69
        for (i = 0; i < num_elem; i++)
 
70
                gcry_md_write(hd, addr[i], len[i]);
 
71
        p = gcry_md_read(hd, GCRY_MD_MD5);
 
72
        if (p)
 
73
                memcpy(mac, p, gcry_md_get_algo_dlen(GCRY_MD_MD5));
 
74
        gcry_md_close(hd);
 
75
}
 
76
 
 
77
 
 
78
void sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
 
79
{
 
80
        gcry_md_hd_t hd;
 
81
        unsigned char *p;
 
82
        size_t i;
 
83
 
 
84
        if (gcry_md_open(&hd, GCRY_MD_SHA1, 0) != GPG_ERR_NO_ERROR)
 
85
                return;
 
86
        for (i = 0; i < num_elem; i++)
 
87
                gcry_md_write(hd, addr[i], len[i]);
 
88
        p = gcry_md_read(hd, GCRY_MD_SHA1);
 
89
        if (p)
 
90
                memcpy(mac, p, gcry_md_get_algo_dlen(GCRY_MD_SHA1));
 
91
        gcry_md_close(hd);
 
92
}
 
93
 
 
94
 
 
95
int fips186_2_prf(const u8 *seed, size_t seed_len, u8 *x, size_t xlen)
 
96
{
 
97
        /* FIX: how to do this with libgcrypt? */
 
98
        return -1;
 
99
}
 
100
 
 
101
 
 
102
void * aes_encrypt_init(const u8 *key, size_t len)
 
103
{
 
104
        gcry_cipher_hd_t hd;
 
105
 
 
106
        if (gcry_cipher_open(&hd, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_ECB, 0) !=
 
107
            GPG_ERR_NO_ERROR) {
 
108
                printf("cipher open failed\n");
 
109
                return NULL;
 
110
        }
 
111
        if (gcry_cipher_setkey(hd, key, len) != GPG_ERR_NO_ERROR) {
 
112
                printf("setkey failed\n");
 
113
                gcry_cipher_close(hd);
 
114
                return NULL;
 
115
        }
 
116
 
 
117
        return hd;
 
118
}
 
119
 
 
120
 
 
121
void aes_encrypt(void *ctx, const u8 *plain, u8 *crypt)
 
122
{
 
123
        gcry_cipher_hd_t hd = ctx;
 
124
        gcry_cipher_encrypt(hd, crypt, 16, plain, 16);
 
125
}
 
126
 
 
127
 
 
128
void aes_encrypt_deinit(void *ctx)
 
129
{
 
130
        gcry_cipher_hd_t hd = ctx;
 
131
        gcry_cipher_close(hd);
 
132
}
 
133
 
 
134
 
 
135
void * aes_decrypt_init(const u8 *key, size_t len)
 
136
{
 
137
        gcry_cipher_hd_t hd;
 
138
 
 
139
        if (gcry_cipher_open(&hd, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_ECB, 0) !=
 
140
            GPG_ERR_NO_ERROR)
 
141
                return NULL;
 
142
        if (gcry_cipher_setkey(hd, key, len) != GPG_ERR_NO_ERROR) {
 
143
                gcry_cipher_close(hd);
 
144
                return NULL;
 
145
        }
 
146
 
 
147
        return hd;
 
148
}
 
149
 
 
150
 
 
151
void aes_decrypt(void *ctx, const u8 *crypt, u8 *plain)
 
152
{
 
153
        gcry_cipher_hd_t hd = ctx;
 
154
        gcry_cipher_decrypt(hd, plain, 16, crypt, 16);
 
155
}
 
156
 
 
157
 
 
158
void aes_decrypt_deinit(void *ctx)
 
159
{
 
160
        gcry_cipher_hd_t hd = ctx;
 
161
        gcry_cipher_close(hd);
 
162
}
 
163
#endif /* EAP_TLS_FUNCS */