Source Code for Module Peach.Transformers.fcrypt

  1  """ 
  2  Unix crypt(3) password hash algorithm. 
  3   
  4  This is a port to Python of the standard Unix password crypt function. 
  5  It's a single self-contained source file that works with any version 
  6  of Python from version 1.5 or higher.  The code is based on Eric 
  7  Young's optimised crypt in C. 
  8   
  9  Python fcrypt is intended for users whose Python installation has not 
 10  had the crypt module enabled, or whose C library doesn't include the 
 11  crypt function.  See the documentation for the Python crypt module for 
 12  more information: 
 13   
 14    http://www.python.org/doc/current/lib/module-crypt.html 
 15   
 16  An alternative Python crypt module that uses the MD5 algorithm and is 
 17  more secure than fcrypt is available from michal j wallace at: 
 18   
 19    http://www.sabren.net/code/python/crypt/index.php3 
 20   
 21  The crypt() function is a one-way hash function, intended to hide a 
 22  password such that the only way to find out the original password is 
 23  to guess values until you get a match.  If you need to encrypt and 
 24  decrypt data, this is not the module for you. 
 25   
 26  There are at least two packages providing Python cryptography support: 
 27  M2Crypto at <http://www.pobox.org.sg/home/ngps/m2/>, and amkCrypto at 
 28  <http://www.amk.ca/python/code/crypto.html>. 
 29   
 30  Functions: 
 31   
 32    crypt() -- return hashed password 
 33  """ 
 34   
 35  __author__ = 'Carey Evans <careye@spamcop.net>' 
 36  __version__ = '1.3.1' 
 37  __date__ = '21 February 2004' 
 38  __credits__ = '''michal j wallace for inspiring me to write this. 
 39  Eric Young for the C code this module was copied from.''' 
 40   
 41  #__all__ = ['crypt'] 
 42   
 43   
 44  # Copyright (C) 2000, 2001, 2004  Carey Evans  <careye@spamcop.net> 
 45  # 
 46  # Permission to use, copy, modify, and distribute this software and 
 47  # its documentation for any purpose and without fee is hereby granted, 
 48  # provided that the above copyright notice appear in all copies and 
 49  # that both that copyright notice and this permission notice appear in 
 50  # supporting documentation. 
 51  # 
 52  # CAREY EVANS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
 53  # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 
 54  # EVENT SHALL CAREY EVANS BE LIABLE FOR ANY SPECIAL, INDIRECT OR 
 55  # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF 
 56  # USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 
 57  # OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 
 58  # PERFORMANCE OF THIS SOFTWARE. 
 59   
 60  # Based on C code by Eric Young (eay@mincom.oz.au), which has the 
 61  # following copyright.  Especially note condition 3, which imposes 
 62  # extra restrictions on top of the standard Python license used above. 
 63  # 
 64  # The fcrypt.c source is available from: 
 65  #     ftp://ftp.psy.uq.oz.au/pub/Crypto/DES/ 
 66   
 67  # ----- BEGIN fcrypt.c LICENSE ----- 
 68  # 
 69  # This library is free for commercial and non-commercial use as long as 
 70  # the following conditions are aheared to.  The following conditions 
 71  # apply to all code found in this distribution, be it the RC4, RSA, 
 72  # lhash, DES, etc., code; not just the SSL code.  The SSL documentation 
 73  # included with this distribution is covered by the same copyright terms 
 74  # except that the holder is Tim Hudson (tjh@mincom.oz.au). 
 75  #  
 76  # Copyright remains Eric Young's, and as such any Copyright notices in 
 77  # the code are not to be removed. 
 78  # If this package is used in a product, Eric Young should be given attribution 
 79  # as the author of the parts of the library used. 
 80  # This can be in the form of a textual message at program startup or 
 81  # in documentation (online or textual) provided with the package. 
 82  #  
 83  # Redistribution and use in source and binary forms, with or without 
 84  # modification, are permitted provided that the following conditions 
 85  # are met: 
 86  # 1. Redistributions of source code must retain the copyright 
 87  #    notice, this list of conditions and the following disclaimer. 
 88  # 2. Redistributions in binary form must reproduce the above copyright 
 89  #    notice, this list of conditions and the following disclaimer in the 
 90  #    documentation and/or other materials provided with the distribution. 
 91  # 3. All advertising materials mentioning features or use of this software 
 92  #    must display the following acknowledgement: 
 93  #    "This product includes cryptographic software written by 
 94  #     Eric Young (eay@mincom.oz.au)" 
 95  #    The word 'cryptographic' can be left out if the rouines from the library 
 96  #    being used are not cryptographic related :-). 
 97  # 4. If you include any Windows specific code (or a derivative thereof) from  
 98  #    the apps directory (application code) you must include an acknowledgement: 
 99  #    "This product includes software written by Tim Hudson (tjh@mincom.oz.au)" 
100  #  
101  # THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 
102  # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
103  # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
104  # ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 
105  # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
106  # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
107  # OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
108  # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
109  # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
110  # OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
111  # SUCH DAMAGE. 
112  #  
113  # The licence and distribution terms for any publically available version or 
114  # derivative of this code cannot be changed.  i.e. this code cannot simply be 
115  # copied and put under another distribution licence 
116  # [including the GNU Public Licence.] 
117  # 
118  # ----- END fcrypt.c LICENSE ----- 
119   
120   
121  import string, struct 
122   
123   
124  _ITERATIONS = 16 
125   
126  _SPtrans = ( 
127      # nibble 0 
128      [ 0x00820200, 0x00020000, 0x80800000, 0x80820200, 
129        0x00800000, 0x80020200, 0x80020000, 0x80800000, 
130        0x80020200, 0x00820200, 0x00820000, 0x80000200, 
131        0x80800200, 0x00800000, 0x00000000, 0x80020000, 
132        0x00020000, 0x80000000, 0x00800200, 0x00020200, 
133        0x80820200, 0x00820000, 0x80000200, 0x00800200, 
134        0x80000000, 0x00000200, 0x00020200, 0x80820000, 
135        0x00000200, 0x80800200, 0x80820000, 0x00000000, 
136        0x00000000, 0x80820200, 0x00800200, 0x80020000, 
137        0x00820200, 0x00020000, 0x80000200, 0x00800200, 
138        0x80820000, 0x00000200, 0x00020200, 0x80800000, 
139        0x80020200, 0x80000000, 0x80800000, 0x00820000, 
140        0x80820200, 0x00020200, 0x00820000, 0x80800200, 
141        0x00800000, 0x80000200, 0x80020000, 0x00000000, 
142        0x00020000, 0x00800000, 0x80800200, 0x00820200, 
143        0x80000000, 0x80820000, 0x00000200, 0x80020200 ], 
144   
145      # nibble 1 
146      [ 0x10042004, 0x00000000, 0x00042000, 0x10040000, 
147        0x10000004, 0x00002004, 0x10002000, 0x00042000, 
148        0x00002000, 0x10040004, 0x00000004, 0x10002000, 
149        0x00040004, 0x10042000, 0x10040000, 0x00000004, 
150        0x00040000, 0x10002004, 0x10040004, 0x00002000, 
151        0x00042004, 0x10000000, 0x00000000, 0x00040004, 
152        0x10002004, 0x00042004, 0x10042000, 0x10000004, 
153        0x10000000, 0x00040000, 0x00002004, 0x10042004, 
154        0x00040004, 0x10042000, 0x10002000, 0x00042004, 
155        0x10042004, 0x00040004, 0x10000004, 0x00000000, 
156        0x10000000, 0x00002004, 0x00040000, 0x10040004, 
157        0x00002000, 0x10000000, 0x00042004, 0x10002004, 
158        0x10042000, 0x00002000, 0x00000000, 0x10000004, 
159        0x00000004, 0x10042004, 0x00042000, 0x10040000, 
160        0x10040004, 0x00040000, 0x00002004, 0x10002000, 
161        0x10002004, 0x00000004, 0x10040000, 0x00042000 ], 
162   
163      # nibble 2 
164      [ 0x41000000, 0x01010040, 0x00000040, 0x41000040, 
165        0x40010000, 0x01000000, 0x41000040, 0x00010040, 
166        0x01000040, 0x00010000, 0x01010000, 0x40000000, 
167        0x41010040, 0x40000040, 0x40000000, 0x41010000, 
168        0x00000000, 0x40010000, 0x01010040, 0x00000040, 
169        0x40000040, 0x41010040, 0x00010000, 0x41000000, 
170        0x41010000, 0x01000040, 0x40010040, 0x01010000, 
171        0x00010040, 0x00000000, 0x01000000, 0x40010040, 
172        0x01010040, 0x00000040, 0x40000000, 0x00010000, 
173        0x40000040, 0x40010000, 0x01010000, 0x41000040, 
174        0x00000000, 0x01010040, 0x00010040, 0x41010000, 
175        0x40010000, 0x01000000, 0x41010040, 0x40000000, 
176        0x40010040, 0x41000000, 0x01000000, 0x41010040, 
177        0x00010000, 0x01000040, 0x41000040, 0x00010040, 
178        0x01000040, 0x00000000, 0x41010000, 0x40000040, 
179        0x41000000, 0x40010040, 0x00000040, 0x01010000 ], 
180   
181      # nibble 3 
182      [ 0x00100402, 0x04000400, 0x00000002, 0x04100402, 
183        0x00000000, 0x04100000, 0x04000402, 0x00100002, 
184        0x04100400, 0x04000002, 0x04000000, 0x00000402, 
185        0x04000002, 0x00100402, 0x00100000, 0x04000000, 
186        0x04100002, 0x00100400, 0x00000400, 0x00000002, 
187        0x00100400, 0x04000402, 0x04100000, 0x00000400, 
188        0x00000402, 0x00000000, 0x00100002, 0x04100400, 
189        0x04000400, 0x04100002, 0x04100402, 0x00100000, 
190        0x04100002, 0x00000402, 0x00100000, 0x04000002, 
191        0x00100400, 0x04000400, 0x00000002, 0x04100000, 
192        0x04000402, 0x00000000, 0x00000400, 0x00100002, 
193        0x00000000, 0x04100002, 0x04100400, 0x00000400, 
194        0x04000000, 0x04100402, 0x00100402, 0x00100000, 
195        0x04100402, 0x00000002, 0x04000400, 0x00100402, 
196        0x00100002, 0x00100400, 0x04100000, 0x04000402, 
197        0x00000402, 0x04000000, 0x04000002, 0x04100400 ], 
198   
199      # nibble 4 
200      [ 0x02000000, 0x00004000, 0x00000100, 0x02004108, 
201        0x02004008, 0x02000100, 0x00004108, 0x02004000, 
202        0x00004000, 0x00000008, 0x02000008, 0x00004100, 
203        0x02000108, 0x02004008, 0x02004100, 0x00000000, 
204        0x00004100, 0x02000000, 0x00004008, 0x00000108, 
205        0x02000100, 0x00004108, 0x00000000, 0x02000008, 
206        0x00000008, 0x02000108, 0x02004108, 0x00004008, 
207        0x02004000, 0x00000100, 0x00000108, 0x02004100, 
208        0x02004100, 0x02000108, 0x00004008, 0x02004000, 
209        0x00004000, 0x00000008, 0x02000008, 0x02000100, 
210        0x02000000, 0x00004100, 0x02004108, 0x00000000, 
211        0x00004108, 0x02000000, 0x00000100, 0x00004008, 
212        0x02000108, 0x00000100, 0x00000000, 0x02004108, 
213        0x02004008, 0x02004100, 0x00000108, 0x00004000, 
214        0x00004100, 0x02004008, 0x02000100, 0x00000108, 
215        0x00000008, 0x00004108, 0x02004000, 0x02000008 ], 
216   
217      # nibble 5 
218      [ 0x20000010, 0x00080010, 0x00000000, 0x20080800, 
219        0x00080010, 0x00000800, 0x20000810, 0x00080000, 
220        0x00000810, 0x20080810, 0x00080800, 0x20000000, 
221        0x20000800, 0x20000010, 0x20080000, 0x00080810, 
222        0x00080000, 0x20000810, 0x20080010, 0x00000000, 
223        0x00000800, 0x00000010, 0x20080800, 0x20080010, 
224        0x20080810, 0x20080000, 0x20000000, 0x00000810, 
225        0x00000010, 0x00080800, 0x00080810, 0x20000800, 
226        0x00000810, 0x20000000, 0x20000800, 0x00080810, 
227        0x20080800, 0x00080010, 0x00000000, 0x20000800, 
228        0x20000000, 0x00000800, 0x20080010, 0x00080000, 
229        0x00080010, 0x20080810, 0x00080800, 0x00000010, 
230        0x20080810, 0x00080800, 0x00080000, 0x20000810, 
231        0x20000010, 0x20080000, 0x00080810, 0x00000000, 
232        0x00000800, 0x20000010, 0x20000810, 0x20080800, 
233        0x20080000, 0x00000810, 0x00000010, 0x20080010 ], 
234   
235      # nibble 6 
236      [ 0x00001000, 0x00000080, 0x00400080, 0x00400001, 
237        0x00401081, 0x00001001, 0x00001080, 0x00000000, 
238        0x00400000, 0x00400081, 0x00000081, 0x00401000, 
239        0x00000001, 0x00401080, 0x00401000, 0x00000081, 
240        0x00400081, 0x00001000, 0x00001001, 0x00401081, 
241        0x00000000, 0x00400080, 0x00400001, 0x00001080, 
242        0x00401001, 0x00001081, 0x00401080, 0x00000001, 
243        0x00001081, 0x00401001, 0x00000080, 0x00400000, 
244        0x00001081, 0x00401000, 0x00401001, 0x00000081, 
245        0x00001000, 0x00000080, 0x00400000, 0x00401001, 
246        0x00400081, 0x00001081, 0x00001080, 0x00000000, 
247        0x00000080, 0x00400001, 0x00000001, 0x00400080, 
248        0x00000000, 0x00400081, 0x00400080, 0x00001080, 
249        0x00000081, 0x00001000, 0x00401081, 0x00400000, 
250        0x00401080, 0x00000001, 0x00001001, 0x00401081, 
251        0x00400001, 0x00401080, 0x00401000, 0x00001001 ], 
252   
253      # nibble 7 
254      [ 0x08200020, 0x08208000, 0x00008020, 0x00000000, 
255        0x08008000, 0x00200020, 0x08200000, 0x08208020, 
256        0x00000020, 0x08000000, 0x00208000, 0x00008020, 
257        0x00208020, 0x08008020, 0x08000020, 0x08200000, 
258        0x00008000, 0x00208020, 0x00200020, 0x08008000, 
259        0x08208020, 0x08000020, 0x00000000, 0x00208000, 
260        0x08000000, 0x00200000, 0x08008020, 0x08200020, 
261        0x00200000, 0x00008000, 0x08208000, 0x00000020, 
262        0x00200000, 0x00008000, 0x08000020, 0x08208020, 
263        0x00008020, 0x08000000, 0x00000000, 0x00208000, 
264        0x08200020, 0x08008020, 0x08008000, 0x00200020, 
265        0x08208000, 0x00000020, 0x00200020, 0x08008000, 
266        0x08208020, 0x00200000, 0x08200000, 0x08000020, 
267        0x00208000, 0x00008020, 0x08008020, 0x08200000, 
268        0x00000020, 0x08208000, 0x00208020, 0x00000000, 
269        0x08000000, 0x08200020, 0x00008000, 0x00208020 ] ) 
270   
271  _skb = ( 
272      # for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 
273      [ 0x00000000, 0x00000010, 0x20000000, 0x20000010, 
274        0x00010000, 0x00010010, 0x20010000, 0x20010010, 
275        0x00000800, 0x00000810, 0x20000800, 0x20000810, 
276        0x00010800, 0x00010810, 0x20010800, 0x20010810, 
277        0x00000020, 0x00000030, 0x20000020, 0x20000030, 
278        0x00010020, 0x00010030, 0x20010020, 0x20010030, 
279        0x00000820, 0x00000830, 0x20000820, 0x20000830, 
280        0x00010820, 0x00010830, 0x20010820, 0x20010830, 
281        0x00080000, 0x00080010, 0x20080000, 0x20080010, 
282        0x00090000, 0x00090010, 0x20090000, 0x20090010, 
283        0x00080800, 0x00080810, 0x20080800, 0x20080810, 
284        0x00090800, 0x00090810, 0x20090800, 0x20090810, 
285        0x00080020, 0x00080030, 0x20080020, 0x20080030, 
286        0x00090020, 0x00090030, 0x20090020, 0x20090030, 
287        0x00080820, 0x00080830, 0x20080820, 0x20080830, 
288        0x00090820, 0x00090830, 0x20090820, 0x20090830 ], 
289   
290      # for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 
291      [ 0x00000000, 0x02000000, 0x00002000, 0x02002000, 
292        0x00200000, 0x02200000, 0x00202000, 0x02202000, 
293        0x00000004, 0x02000004, 0x00002004, 0x02002004, 
294        0x00200004, 0x02200004, 0x00202004, 0x02202004, 
295        0x00000400, 0x02000400, 0x00002400, 0x02002400, 
296        0x00200400, 0x02200400, 0x00202400, 0x02202400, 
297        0x00000404, 0x02000404, 0x00002404, 0x02002404, 
298        0x00200404, 0x02200404, 0x00202404, 0x02202404, 
299        0x10000000, 0x12000000, 0x10002000, 0x12002000, 
300        0x10200000, 0x12200000, 0x10202000, 0x12202000, 
301        0x10000004, 0x12000004, 0x10002004, 0x12002004, 
302        0x10200004, 0x12200004, 0x10202004, 0x12202004, 
303        0x10000400, 0x12000400, 0x10002400, 0x12002400, 
304        0x10200400, 0x12200400, 0x10202400, 0x12202400, 
305        0x10000404, 0x12000404, 0x10002404, 0x12002404, 
306        0x10200404, 0x12200404, 0x10202404, 0x12202404 ], 
307   
308      # for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 
309      [ 0x00000000, 0x00000001, 0x00040000, 0x00040001, 
310        0x01000000, 0x01000001, 0x01040000, 0x01040001, 
311        0x00000002, 0x00000003, 0x00040002, 0x00040003, 
312        0x01000002, 0x01000003, 0x01040002, 0x01040003, 
313        0x00000200, 0x00000201, 0x00040200, 0x00040201, 
314        0x01000200, 0x01000201, 0x01040200, 0x01040201, 
315        0x00000202, 0x00000203, 0x00040202, 0x00040203, 
316        0x01000202, 0x01000203, 0x01040202, 0x01040203, 
317        0x08000000, 0x08000001, 0x08040000, 0x08040001, 
318        0x09000000, 0x09000001, 0x09040000, 0x09040001, 
319        0x08000002, 0x08000003, 0x08040002, 0x08040003, 
320        0x09000002, 0x09000003, 0x09040002, 0x09040003, 
321        0x08000200, 0x08000201, 0x08040200, 0x08040201, 
322        0x09000200, 0x09000201, 0x09040200, 0x09040201, 
323        0x08000202, 0x08000203, 0x08040202, 0x08040203, 
324        0x09000202, 0x09000203, 0x09040202, 0x09040203 ], 
325   
326      # for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 
327      [ 0x00000000, 0x00100000, 0x00000100, 0x00100100, 
328        0x00000008, 0x00100008, 0x00000108, 0x00100108, 
329        0x00001000, 0x00101000, 0x00001100, 0x00101100, 
330        0x00001008, 0x00101008, 0x00001108, 0x00101108, 
331        0x04000000, 0x04100000, 0x04000100, 0x04100100, 
332        0x04000008, 0x04100008, 0x04000108, 0x04100108, 
333        0x04001000, 0x04101000, 0x04001100, 0x04101100, 
334        0x04001008, 0x04101008, 0x04001108, 0x04101108, 
335        0x00020000, 0x00120000, 0x00020100, 0x00120100, 
336        0x00020008, 0x00120008, 0x00020108, 0x00120108, 
337        0x00021000, 0x00121000, 0x00021100, 0x00121100, 
338        0x00021008, 0x00121008, 0x00021108, 0x00121108, 
339        0x04020000, 0x04120000, 0x04020100, 0x04120100, 
340        0x04020008, 0x04120008, 0x04020108, 0x04120108, 
341        0x04021000, 0x04121000, 0x04021100, 0x04121100, 
342        0x04021008, 0x04121008, 0x04021108, 0x04121108 ], 
343   
344      # for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 
345      [ 0x00000000, 0x10000000, 0x00010000, 0x10010000, 
346        0x00000004, 0x10000004, 0x00010004, 0x10010004, 
347        0x20000000, 0x30000000, 0x20010000, 0x30010000, 
348        0x20000004, 0x30000004, 0x20010004, 0x30010004, 
349        0x00100000, 0x10100000, 0x00110000, 0x10110000, 
350        0x00100004, 0x10100004, 0x00110004, 0x10110004, 
351        0x20100000, 0x30100000, 0x20110000, 0x30110000, 
352        0x20100004, 0x30100004, 0x20110004, 0x30110004, 
353        0x00001000, 0x10001000, 0x00011000, 0x10011000, 
354        0x00001004, 0x10001004, 0x00011004, 0x10011004, 
355        0x20001000, 0x30001000, 0x20011000, 0x30011000, 
356        0x20001004, 0x30001004, 0x20011004, 0x30011004, 
357        0x00101000, 0x10101000, 0x00111000, 0x10111000, 
358        0x00101004, 0x10101004, 0x00111004, 0x10111004, 
359        0x20101000, 0x30101000, 0x20111000, 0x30111000, 
360        0x20101004, 0x30101004, 0x20111004, 0x30111004 ], 
361   
362      # for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 
363      [ 0x00000000, 0x08000000, 0x00000008, 0x08000008, 
364        0x00000400, 0x08000400, 0x00000408, 0x08000408, 
365        0x00020000, 0x08020000, 0x00020008, 0x08020008, 
366        0x00020400, 0x08020400, 0x00020408, 0x08020408, 
367        0x00000001, 0x08000001, 0x00000009, 0x08000009, 
368        0x00000401, 0x08000401, 0x00000409, 0x08000409, 
369        0x00020001, 0x08020001, 0x00020009, 0x08020009, 
370        0x00020401, 0x08020401, 0x00020409, 0x08020409, 
371        0x02000000, 0x0A000000, 0x02000008, 0x0A000008, 
372        0x02000400, 0x0A000400, 0x02000408, 0x0A000408, 
373        0x02020000, 0x0A020000, 0x02020008, 0x0A020008, 
374        0x02020400, 0x0A020400, 0x02020408, 0x0A020408, 
375        0x02000001, 0x0A000001, 0x02000009, 0x0A000009, 
376        0x02000401, 0x0A000401, 0x02000409, 0x0A000409, 
377        0x02020001, 0x0A020001, 0x02020009, 0x0A020009, 
378        0x02020401, 0x0A020401, 0x02020409, 0x0A020409 ], 
379   
380      # for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 
381      [ 0x00000000, 0x00000100, 0x00080000, 0x00080100, 
382        0x01000000, 0x01000100, 0x01080000, 0x01080100, 
383        0x00000010, 0x00000110, 0x00080010, 0x00080110, 
384        0x01000010, 0x01000110, 0x01080010, 0x01080110, 
385        0x00200000, 0x00200100, 0x00280000, 0x00280100, 
386        0x01200000, 0x01200100, 0x01280000, 0x01280100, 
387        0x00200010, 0x00200110, 0x00280010, 0x00280110, 
388        0x01200010, 0x01200110, 0x01280010, 0x01280110, 
389        0x00000200, 0x00000300, 0x00080200, 0x00080300, 
390        0x01000200, 0x01000300, 0x01080200, 0x01080300, 
391        0x00000210, 0x00000310, 0x00080210, 0x00080310, 
392        0x01000210, 0x01000310, 0x01080210, 0x01080310, 
393        0x00200200, 0x00200300, 0x00280200, 0x00280300, 
394        0x01200200, 0x01200300, 0x01280200, 0x01280300, 
395        0x00200210, 0x00200310, 0x00280210, 0x00280310, 
396        0x01200210, 0x01200310, 0x01280210, 0x01280310 ], 
397   
398      # for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 
399      [ 0x00000000, 0x04000000, 0x00040000, 0x04040000, 
400        0x00000002, 0x04000002, 0x00040002, 0x04040002, 
401        0x00002000, 0x04002000, 0x00042000, 0x04042000, 
402        0x00002002, 0x04002002, 0x00042002, 0x04042002, 
403        0x00000020, 0x04000020, 0x00040020, 0x04040020, 
404        0x00000022, 0x04000022, 0x00040022, 0x04040022, 
405        0x00002020, 0x04002020, 0x00042020, 0x04042020, 
406        0x00002022, 0x04002022, 0x00042022, 0x04042022, 
407        0x00000800, 0x04000800, 0x00040800, 0x04040800, 
408        0x00000802, 0x04000802, 0x00040802, 0x04040802, 
409        0x00002800, 0x04002800, 0x00042800, 0x04042800, 
410        0x00002802, 0x04002802, 0x00042802, 0x04042802, 
411        0x00000820, 0x04000820, 0x00040820, 0x04040820, 
412        0x00000822, 0x04000822, 0x00040822, 0x04040822, 
413        0x00002820, 0x04002820, 0x00042820, 0x04042820, 
414        0x00002822, 0x04002822, 0x00042822, 0x04042822 ] ) 
415   
416  _shifts2 = (0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0) 
417   
418  _con_salt = [ 
419      0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9, 
420      0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1, 
421      0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9, 
422      0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1, 
423      0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9, 
424      0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,0x00,0x01, 
425      0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09, 
426      0x0A,0x0B,0x05,0x06,0x07,0x08,0x09,0x0A, 
427      0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12, 
428      0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A, 
429      0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22, 
430      0x23,0x24,0x25,0x20,0x21,0x22,0x23,0x24, 
431      0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C, 
432      0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34, 
433      0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C, 
434      0x3D,0x3E,0x3F,0x40,0x41,0x42,0x43,0x44 ] 
435   
436  _cov_2char = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' 
437   
438   
439 -def _HPERM_OP(a): 
440      """Clever bit manipulation.""" 
441      t = ((a << 18) ^ a) & 0xcccc0000 
442      return a ^ t ^ ((t >> 18) & 0x3fff) 
443   
444 -def _PERM_OP(a,b,n,m): 
445      """Cleverer bit manipulation.""" 
446      t = ((a >> n) ^ b) & m 
447      b = b ^ t 
448      a = a ^ (t << n) 
449      return a,b 
450   
451   
452 -def _set_key(password): 
453      """Generate DES key schedule from ASCII password.""" 
454   
455      c,d = struct.unpack('<ii', password) 
456      c = (c & 0x7f7f7f7f) << 1 
457      d = (d & 0x7f7f7f7f) << 1 
458   
459      d,c = _PERM_OP(d,c,4,0x0f0f0f0f) 
460      c = _HPERM_OP(c) 
461      d = _HPERM_OP(d) 
462      d,c = _PERM_OP(d,c,1,0x55555555) 
463      c,d = _PERM_OP(c,d,8,0x00ff00ff) 
464      d,c = _PERM_OP(d,c,1,0x55555555) 
465   
466      # Any sign-extended bits are masked off. 
467      d = (((d & 0x000000ff) << 16) | (d & 0x0000ff00) | 
468           ((d & 0x00ff0000) >> 16) | ((c >> 4) & 0x0f000000)) 
469      c = c & 0x0fffffff 
470   
471      # Copy globals into local variables for loop. 
472      shifts2 = _shifts2 
473      skbc0, skbc1, skbc2, skbc3, skbd0, skbd1, skbd2, skbd3 = _skb 
474   
475      k = [0] * (_ITERATIONS * 2) 
476   
477      for i in range(_ITERATIONS): 
478          # Only operates on top 28 bits. 
479          if shifts2[i]: 
480              c = (c >> 2) | (c << 26) 
481              d = (d >> 2) | (d << 26) 
482          else: 
483              c = (c >> 1) | (c << 27) 
484              d = (d >> 1) | (d << 27) 
485          c = c & 0x0fffffff 
486          d = d & 0x0fffffff 
487   
488          s = ( skbc0[  c      & 0x3f                    ] | 
489                skbc1[((c>> 6) & 0x03) | ((c>> 7) & 0x3c)] | 
490                skbc2[((c>>13) & 0x0f) | ((c>>14) & 0x30)] | 
491                skbc3[((c>>20) & 0x01) | 
492                      ((c>>21) & 0x06) | ((c>>22) & 0x38)] ) 
493   
494          t = ( skbd0[  d      & 0x3f                    ] | 
495                skbd1[((d>> 7) & 0x03) | ((d>> 8) & 0x3c)] | 
496                skbd2[((d>>15) & 0x3f)                   ] | 
497                skbd3[((d>>21) & 0x0f) | ((d>>22) & 0x30)] ) 
498   
499          k[2*i] = ((t << 16) | (s & 0x0000ffff)) & 0xffffffff 
500          s = (s >> 16) | (t & 0xffff0000) 
501   
502          # Top bit of s may be 1. 
503          s = (s << 4) | ((s >> 28) & 0x0f) 
504          k[2*i + 1] = s & 0xffffffff 
505   
506      return k 
507   
508   
509 -def _body(ks, E0, E1): 
510      """Use the key schedule ks and salt E0, E1 to create the password hash.""" 
511   
512      # Copy global variable into locals for loop. 
513      SP0, SP1, SP2, SP3, SP4, SP5, SP6, SP7 = _SPtrans 
514   
515      inner = range(0, _ITERATIONS*2, 2) 
516      l = r = 0 
517      for j in range(25): 
518          l,r = r,l 
519          for i in inner: 
520              t = r ^ ((r >> 16) & 0xffff) 
521              u = t & E0 
522              t = t & E1 
523              u = u ^ (u << 16) ^ r ^ ks[i] 
524              t = t ^ (t << 16) ^ r ^ ks[i+1] 
525              t = ((t >> 4) & 0x0fffffff) | (t << 28) 
526   
527              l,r = r,(SP1[(t    ) & 0x3f] ^ SP3[(t>> 8) & 0x3f] ^ 
528                       SP5[(t>>16) & 0x3f] ^ SP7[(t>>24) & 0x3f] ^ 
529                       SP0[(u    ) & 0x3f] ^ SP2[(u>> 8) & 0x3f] ^ 
530                       SP4[(u>>16) & 0x3f] ^ SP6[(u>>24) & 0x3f] ^ l) 
531   
532      l = ((l >> 1) & 0x7fffffff) | ((l & 0x1) << 31) 
533      r = ((r >> 1) & 0x7fffffff) | ((r & 0x1) << 31) 
534   
535      r,l = _PERM_OP(r, l,  1, 0x55555555) 
536      l,r = _PERM_OP(l, r,  8, 0x00ff00ff) 
537      r,l = _PERM_OP(r, l,  2, 0x33333333) 
538      l,r = _PERM_OP(l, r, 16, 0x0000ffff) 
539      r,l = _PERM_OP(r, l,  4, 0x0f0f0f0f) 
540   
541      return l,r 
542   
543   
544 -def crypt(password, salt): 
545      """Generate an encrypted hash from the passed password.  If the password 
546  is longer than eight characters, only the first eight will be used. 
547   
548  The first two characters of the salt are used to modify the encryption 
549  algorithm used to generate in the hash in one of 4096 different ways. 
550  The characters for the salt should be upper- and lower-case letters A 
551  to Z, digits 0 to 9, '.' and '/'. 
552   
553  The returned hash begins with the two characters of the salt, and 
554  should be passed as the salt to verify the password. 
555   
556  Example: 
557   
558    >>> from fcrypt import crypt 
559    >>> password = 'AlOtBsOl' 
560    >>> salt = 'cE' 
561    >>> hash = crypt(password, salt) 
562    >>> hash 
563    'cEpWz5IUCShqM' 
564    >>> crypt(password, hash) == hash 
565    1 
566    >>> crypt('IaLaIoK', hash) == hash 
567    0 
568   
569  In practice, you would read the password using something like the 
570  getpass module, and generate the salt randomly: 
571   
572    >>> import random, string 
573    >>> saltchars = string.letters + string.digits + './' 
574    >>> salt = random.choice(saltchars) + random.choice(saltchars) 
575   
576  Note that other ASCII characters are accepted in the salt, but the 
577  results may not be the same as other versions of crypt.  In 
578  particular, '_', '$1' and '$2' do not select alternative hash 
579  algorithms such as the extended passwords, MD5 crypt and Blowfish 
580  crypt supported by the OpenBSD C library. 
581  """ 
582   
583      # Extract the salt. 
584      if len(salt) == 0: 
585          salt = 'AA' 
586      elif len(salt) == 1: 
587          salt = salt + 'A' 
588      Eswap0 = _con_salt[ord(salt[0]) & 0x7f] 
589      Eswap1 = _con_salt[ord(salt[1]) & 0x7f] << 4 
590   
591      # Generate the key and use it to apply the encryption. 
592      ks = _set_key((password + '\0\0\0\0\0\0\0\0')[:8]) 
593      o1, o2 = _body(ks, Eswap0, Eswap1) 
594   
595      # Extract 24-bit subsets of result with bytes reversed. 
596      t1 = (o1 << 16 & 0xff0000) | (o1 & 0xff00) | (o1 >> 16 & 0xff) 
597      t2 = (o1 >> 8 & 0xff0000) | (o2 << 8 & 0xff00) | (o2 >> 8 & 0xff) 
598      t3 = (o2 & 0xff0000) | (o2 >> 16 & 0xff00) 
599      # Extract 6-bit subsets. 
600      r = [ t1 >> 18 & 0x3f, t1 >> 12 & 0x3f, t1 >> 6 & 0x3f, t1 & 0x3f, 
601            t2 >> 18 & 0x3f, t2 >> 12 & 0x3f, t2 >> 6 & 0x3f, t2 & 0x3f, 
602            t3 >> 18 & 0x3f, t3 >> 12 & 0x3f, t3 >> 6 & 0x3f ] 
603      # Convert to characters. 
604      for i in range(len(r)): 
605          r[i] = _cov_2char[r[i]] 
606      return salt[:2] + string.join(r, '') 
607   
608 -def _test(): 
609      """Run doctest on fcrypt module.""" 
610      import doctest, fcrypt 
611      return doctest.testmod(fcrypt) 
612   
613  if __name__ == '__main__': 
614      _test() 
615