git.zerfleddert.de Git - proxmark3-svn/blob

1 /*

2 * libopenemv - a library to work with EMV family of smart cards

4 *

5 * This library is free software; you can redistribute it and/or

6 * modify it under the terms of the GNU Lesser General Public

7 * License as published by the Free Software Foundation; either

8 * version 2.1 of the License, or (at your option) any later version.

9 *

10 * This library is distributed in the hope that it will be useful,

11 * but WITHOUT ANY WARRANTY; without even the implied warranty of

12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

13 * Lesser General Public License for more details.

14 */

16 #ifdef HAVE_CONFIG_H

17 #include <config.h>

18 #endif

20 #include "crypto.h"

21 #include "crypto_backend.h"

23 #include <string.h>

25 static struct crypto_backend *crypto_backend;

 static bool crypto_init(void)

28 {

29 if (crypto_backend)

30 return true;

32 crypto_backend = crypto_polarssl_init();

34 if (!crypto_backend)

35 return false;

37 return true;

38 }

 struct crypto_hash *crypto_hash_open(enum crypto_algo_hash hash)

41 {

42 struct crypto_hash *ch;

44 if (!crypto_init())

45 return NULL;

         ch = crypto_backend->hash_open(hash);

48 if (ch)

49 ch->algo = hash;

51 return ch;

52 }

 void crypto_hash_close(struct crypto_hash *ch)

55 {

56 ch->close(ch);

57 }

 void crypto_hash_write(struct crypto_hash *ch, const unsigned char *buf, size_t len)

60 {

         ch->write(ch, buf, len);

62 }

 unsigned char *crypto_hash_read(struct crypto_hash *ch)

65 {

         return ch->read(ch);

67 }

 size_t crypto_hash_get_size(const struct crypto_hash *ch)

70 {

         return ch->get_size(ch);

72 }

 struct crypto_pk *crypto_pk_open(enum crypto_algo_pk pk, ...)

75 {

76 struct crypto_pk *cp;

77 va_list vl;

79 if (!crypto_init())

80 return NULL;

82 va_start(vl, pk);

         cp = crypto_backend->pk_open(pk, vl);

84 va_end(vl);

86 if (cp)

87 cp->algo = pk;

89 return cp;

90 }

 struct crypto_pk *crypto_pk_open_priv(enum crypto_algo_pk pk, ...)

93 {

94 struct crypto_pk *cp;

95 va_list vl;

97 if (!crypto_init())

98 return NULL;

100 if (!crypto_backend->pk_open_priv)

101 return NULL;

102

103 va_start(vl, pk);

         cp = crypto_backend->pk_open_priv(pk, vl);

105 va_end(vl);

106

107 if (cp)

108 cp->algo = pk;

109

110 return cp;

111 }

112

 struct crypto_pk *crypto_pk_genkey(enum crypto_algo_pk pk, ...)

114 {

115 struct crypto_pk *cp;

116 va_list vl;

117

118 if (!crypto_init())

119 return NULL;

120

121 if (!crypto_backend->pk_genkey)

122 return NULL;

123

124 va_start(vl, pk);

         cp = crypto_backend->pk_genkey(pk, vl);

126 va_end(vl);

127

128 if (cp)

129 cp->algo = pk;

130

131 return cp;

132 }

133

 void crypto_pk_close(struct crypto_pk *cp)

135 {

136 cp->close(cp);

137 }

138

 unsigned char *crypto_pk_encrypt(const struct crypto_pk *cp, const unsigned char *buf, size_t len, size_t *clen)

140 {

         return cp->encrypt(cp, buf, len, clen);

142 }

143

 unsigned char *crypto_pk_decrypt(const struct crypto_pk *cp, const unsigned char *buf, size_t len, size_t *clen)

145 {

146 if (!cp->decrypt) {

147 *clen = 0;

148

149 return NULL;

150 }

151

         return cp->decrypt(cp, buf, len, clen);

153 }

154

 enum crypto_algo_pk crypto_pk_get_algo(const struct crypto_pk *cp)

156 {

157 if (!cp)

158 return PK_INVALID;

159

160 return cp->algo;

161 }

162

 size_t crypto_pk_get_nbits(const struct crypto_pk *cp)

164 {

165 if (!cp->get_nbits)

166 return 0;

167

         return cp->get_nbits(cp);

169 }

170

 unsigned char *crypto_pk_get_parameter(const struct crypto_pk *cp, unsigned param, size_t *plen)

172 {

173 *plen = 0;

174

175 if (!cp->get_parameter)

176 return NULL;

177

         return cp->get_parameter(cp, param, plen);

179 }