**diff options**

Diffstat (limited to 'src/daemon/https/lgl/gc-pbkdf2-sha1.c')

-rw-r--r-- | src/daemon/https/lgl/gc-pbkdf2-sha1.c | 185 |

1 files changed, 0 insertions, 185 deletions

diff --git a/src/daemon/https/lgl/gc-pbkdf2-sha1.c b/src/daemon/https/lgl/gc-pbkdf2-sha1.c deleted file mode 100644 index f58ba491..00000000 --- a/src/daemon/https/lgl/gc-pbkdf2-sha1.c +++ /dev/null | |||

@@ -1,185 +0,0 @@ | |||

1 | /* gc-pbkdf2-sha1.c --- Password-Based Key Derivation Function a'la PKCS#5 | ||

2 | Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. | ||

3 | |||

4 | This program is free software; you can redistribute it and/or modify | ||

5 | it under the terms of the GNU Lesser General Public License as published by | ||

6 | the Free Software Foundation; either version 2.1, or (at your option) | ||

7 | any later version. | ||

8 | |||

9 | This program is distributed in the hope that it will be useful, | ||

10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||

11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||

12 | GNU Lesser General Public License for more details. | ||

13 | |||

14 | You should have received a copy of the GNU Lesser General Public License | ||

15 | along with this program; if not, write to the Free Software Foundation, | ||

16 | Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ | ||

17 | |||

18 | /* Written by Simon Josefsson. The comments in this file are taken | ||

19 | from RFC 2898. */ | ||

20 | |||

21 | #include "MHD_config.h" | ||

22 | |||

23 | #include "gc.h" | ||

24 | |||

25 | #include <stdlib.h> | ||

26 | #include <string.h> | ||

27 | |||

28 | /* | ||

29 | * 5.2 PBKDF2 | ||

30 | * | ||

31 | * PBKDF2 applies a pseudorandom function (see Appendix B.1 for an | ||

32 | * example) to derive keys. The length of the derived key is essentially | ||

33 | * unbounded. (However, the maximum effective search space for the | ||

34 | * derived key may be limited by the structure of the underlying | ||

35 | * pseudorandom function. See Appendix B.1 for further discussion.) | ||

36 | * PBKDF2 is recommended for new applications. | ||

37 | * | ||

38 | * PBKDF2 (P, S, c, dkLen) | ||

39 | * | ||

40 | * Options: PRF underlying pseudorandom function (hLen | ||

41 | * denotes the length in octets of the | ||

42 | * pseudorandom function output) | ||

43 | * | ||

44 | * Input: P password, an octet string (ASCII or UTF-8) | ||

45 | * S salt, an octet string | ||

46 | * c iteration count, a positive integer | ||

47 | * dkLen intended length in octets of the derived | ||

48 | * key, a positive integer, at most | ||

49 | * (2^32 - 1) * hLen | ||

50 | * | ||

51 | * Output: DK derived key, a dkLen-octet string | ||

52 | */ | ||

53 | |||

54 | Gc_rc | ||

55 | MHD_gc_pbkdf2_sha1 (const char *P, size_t Plen, | ||

56 | const char *S, size_t Slen, | ||

57 | unsigned int c, char *DK, size_t dkLen) | ||

58 | { | ||

59 | unsigned int hLen = 20; | ||

60 | char U[20]; | ||

61 | char T[20]; | ||

62 | unsigned int u; | ||

63 | unsigned int l; | ||

64 | unsigned int r; | ||

65 | unsigned int i; | ||

66 | unsigned int k; | ||

67 | int rc; | ||

68 | char *tmp; | ||

69 | size_t tmplen = Slen + 4; | ||

70 | |||

71 | if (c == 0) | ||

72 | return GC_PKCS5_INVALID_ITERATION_COUNT; | ||

73 | |||

74 | if (dkLen == 0) | ||

75 | return GC_PKCS5_INVALID_DERIVED_KEY_LENGTH; | ||

76 | |||

77 | /* | ||

78 | * | ||

79 | * Steps: | ||

80 | * | ||

81 | * 1. If dkLen > (2^32 - 1) * hLen, output "derived key too long" and | ||

82 | * stop. | ||

83 | */ | ||

84 | |||

85 | if (dkLen > 4294967295U) | ||

86 | return GC_PKCS5_DERIVED_KEY_TOO_LONG; | ||

87 | |||

88 | /* | ||

89 | * 2. Let l be the number of hLen-octet blocks in the derived key, | ||

90 | * rounding up, and let r be the number of octets in the last | ||

91 | * block: | ||

92 | * | ||

93 | * l = CEIL (dkLen / hLen) , | ||

94 | * r = dkLen - (l - 1) * hLen . | ||

95 | * | ||

96 | * Here, CEIL (x) is the "ceiling" function, i.e. the smallest | ||

97 | * integer greater than, or equal to, x. | ||

98 | */ | ||

99 | |||

100 | l = ((dkLen - 1) / hLen) + 1; | ||

101 | r = dkLen - (l - 1) * hLen; | ||

102 | |||

103 | /* | ||

104 | * 3. For each block of the derived key apply the function F defined | ||

105 | * below to the password P, the salt S, the iteration count c, and | ||

106 | * the block index to compute the block: | ||

107 | * | ||

108 | * T_1 = F (P, S, c, 1) , | ||

109 | * T_2 = F (P, S, c, 2) , | ||

110 | * ... | ||

111 | * T_l = F (P, S, c, l) , | ||

112 | * | ||

113 | * where the function F is defined as the exclusive-or sum of the | ||

114 | * first c iterates of the underlying pseudorandom function PRF | ||

115 | * applied to the password P and the concatenation of the salt S | ||

116 | * and the block index i: | ||

117 | * | ||

118 | * F (P, S, c, i) = U_1 \xor U_2 \xor ... \xor U_c | ||

119 | * | ||

120 | * where | ||

121 | * | ||

122 | * U_1 = PRF (P, S || INT (i)) , | ||

123 | * U_2 = PRF (P, U_1) , | ||

124 | * ... | ||

125 | * U_c = PRF (P, U_{c-1}) . | ||

126 | * | ||

127 | * Here, INT (i) is a four-octet encoding of the integer i, most | ||

128 | * significant octet first. | ||

129 | * | ||

130 | * 4. Concatenate the blocks and extract the first dkLen octets to | ||

131 | * produce a derived key DK: | ||

132 | * | ||

133 | * DK = T_1 || T_2 || ... || T_l<0..r-1> | ||

134 | * | ||

135 | * 5. Output the derived key DK. | ||

136 | * | ||

137 | * Note. The construction of the function F follows a "belt-and- | ||

138 | * suspenders" approach. The iterates U_i are computed recursively to | ||

139 | * remove a degree of parallelism from an opponent; they are exclusive- | ||

140 | * ored together to reduce concerns about the recursion degenerating | ||

141 | * into a small set of values. | ||

142 | * | ||

143 | */ | ||

144 | |||

145 | tmp = malloc (tmplen); | ||

146 | if (tmp == NULL) | ||

147 | return GC_MALLOC_ERROR; | ||

148 | |||

149 | memcpy (tmp, S, Slen); | ||

150 | |||

151 | for (i = 1; i <= l; i++) | ||

152 | { | ||

153 | memset (T, 0, hLen); | ||

154 | |||

155 | for (u = 1; u <= c; u++) | ||

156 | { | ||

157 | if (u == 1) | ||

158 | { | ||

159 | tmp[Slen + 0] = (i & 0xff000000) >> 24; | ||

160 | tmp[Slen + 1] = (i & 0x00ff0000) >> 16; | ||

161 | tmp[Slen + 2] = (i & 0x0000ff00) >> 8; | ||

162 | tmp[Slen + 3] = (i & 0x000000ff) >> 0; | ||

163 | |||

164 | rc = MHD_gc_MHD_hmac_sha1 (P, Plen, tmp, tmplen, U); | ||

165 | } | ||

166 | else | ||

167 | rc = MHD_gc_MHD_hmac_sha1 (P, Plen, U, hLen, U); | ||

168 | |||

169 | if (rc != GC_OK) | ||

170 | { | ||

171 | free (tmp); | ||

172 | return rc; | ||

173 | } | ||

174 | |||

175 | for (k = 0; k < hLen; k++) | ||

176 | T[k] ^= U[k]; | ||

177 | } | ||

178 | |||

179 | memcpy (DK + (i - 1) * hLen, T, i == l ? r : hLen); | ||

180 | } | ||

181 | |||

182 | free (tmp); | ||

183 | |||

184 | return GC_OK; | ||

185 | } | ||