turbine-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sgoes...@apache.org
Subject svn commit: r581797 - in /turbine/fulcrum/trunk/crypto: ./ src/java/org/apache/fulcrum/crypto/ src/java/org/apache/fulcrum/crypto/impl/ src/java/org/apache/fulcrum/crypto/provider/ xdocs/
Date Thu, 04 Oct 2007 08:26:19 GMT
Author: sgoeschl
Date: Thu Oct  4 01:26:18 2007
New Revision: 581797

URL: http://svn.apache.org/viewvc?rev=581797&view=rev
Log:
Getting rid of all external dependencies - especially the denpendency on the cryptix library.

Added:
    turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/impl/
    turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/impl/Base64.java
    turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/impl/UnixCrypt.java
Modified:
    turbine/fulcrum/trunk/crypto/project.xml
    turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/DefaultCryptoService.java
    turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/JavaCrypt.java
    turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/OldJavaCrypt.java
    turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/UnixCrypt.java
    turbine/fulcrum/trunk/crypto/xdocs/changes.xml
    turbine/fulcrum/trunk/crypto/xdocs/index.xml

Modified: turbine/fulcrum/trunk/crypto/project.xml
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/crypto/project.xml?rev=581797&r1=581796&r2=581797&view=diff
==============================================================================
--- turbine/fulcrum/trunk/crypto/project.xml (original)
+++ turbine/fulcrum/trunk/crypto/project.xml Thu Oct  4 01:26:18 2007
@@ -32,40 +32,19 @@
       <tag>FULCRUM_CRYPTO_1_0_5</tag>
     </version>
   </versions>
+  
   <dependencies>
-
-   <dependency>
-      <groupId>javax.mail</groupId>
-      <artifactId>mail</artifactId>
-      <version>1.3.3</version>
-      <url>http://java.sun.com/products/javamail/</url>
-    </dependency>
-
-    <dependency>
-      <groupId>commons-codec</groupId>
-      <artifactId>commons-codec</artifactId>
-      <version>1.3</version>
-    </dependency>
-
-    <dependency>
-      <groupId>cryptix</groupId>
-      <artifactId>cryptix</artifactId>
-      <version>3.2.0</version>
-    </dependency>
-
     <!--  Needed only for testing -->
     <dependency>
       <groupId>fulcrum</groupId>
       <artifactId>fulcrum-testcontainer</artifactId>
       <version>1.0.5</version>
     </dependency>
-
     <dependency>
       <groupId>fulcrum</groupId>
       <artifactId>fulcrum-yaafi</artifactId>
       <version>1.0.4</version>
     </dependency>
-
   </dependencies>
 
 </project>

Modified: turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/DefaultCryptoService.java
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/DefaultCryptoService.java?rev=581797&r1=581796&r2=581797&view=diff
==============================================================================
--- turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/DefaultCryptoService.java
(original)
+++ turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/DefaultCryptoService.java
Thu Oct  4 01:26:18 2007
@@ -56,7 +56,6 @@
     /** Default Encryption Class */
     private static final String DEFAULT_CLASS =
       "org.apache.fulcrum.crypto.provider.JavaCrypt";
-    private boolean disposed = false;
     /** Names of the registered algorithms and the wanted classes */
     private Hashtable algos = null;
 
@@ -142,7 +141,7 @@
      */
     public void dispose()
     {
-        disposed = true;
+        algos = null;
     }
 
 }

Added: turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/impl/Base64.java
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/impl/Base64.java?rev=581797&view=auto
==============================================================================
--- turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/impl/Base64.java (added)
+++ turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/impl/Base64.java Thu Oct
 4 01:26:18 2007
@@ -0,0 +1,294 @@
+package org.apache.fulcrum.crypto.impl;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * Base64 encoder/decoder taken from commons-codec. Copying
+ * and wasting the code allows to minimize the dependencies.
+ *
+ * @author Siegfried Goeschl
+ */
+public class Base64
+{
+
+    public Base64() {
+    }
+
+    private static boolean isBase64(byte octect) {
+        if(octect == 61)
+            return true;
+        return base64Alphabet[octect] != -1;
+    }
+
+    public static boolean isArrayByteBase64(byte arrayOctect[]) {
+        arrayOctect = discardWhitespace(arrayOctect);
+        int length = arrayOctect.length;
+        if(length == 0)
+            return true;
+        for(int i = 0; i < length; i++)
+            if(!isBase64(arrayOctect[i]))
+                return false;
+
+        return true;
+    }
+
+    public static byte[] encodeBase64(byte binaryData[]) {
+        return encodeBase64(binaryData, false);
+    }
+
+    public static byte[] encodeBase64Chunked(byte binaryData[]) {
+        return encodeBase64(binaryData, true);
+    }
+
+    public Object decode(Object pObject)
+        throws Exception {
+        if(!(pObject instanceof byte[]))
+            throw new Exception("Parameter supplied to Base64 decode is not a byte[]");
+        else
+            return decode((byte[])pObject);
+    }
+
+    public byte[] decode(byte pArray[]) {
+        return decodeBase64(pArray);
+    }
+
+    public static byte[] encodeBase64(byte binaryData[], boolean isChunked) {
+        int lengthDataBits = binaryData.length * 8;
+        int fewerThan24bits = lengthDataBits % 24;
+        int numberTriplets = lengthDataBits / 24;
+        byte encodedData[] = null;
+        int encodedDataLength = 0;
+        int nbrChunks = 0;
+        if(fewerThan24bits != 0)
+            encodedDataLength = (numberTriplets + 1) * 4;
+        else
+            encodedDataLength = numberTriplets * 4;
+        if(isChunked) {
+            nbrChunks = CHUNK_SEPARATOR.length != 0 ? (int)Math.ceil((float)encodedDataLength
/ 76F) : 0;
+            encodedDataLength += nbrChunks * CHUNK_SEPARATOR.length;
+        }
+        encodedData = new byte[encodedDataLength];
+        byte k = 0;
+        byte l = 0;
+        byte b1 = 0;
+        byte b2 = 0;
+        byte b3 = 0;
+        int encodedIndex = 0;
+        int dataIndex = 0;
+        int i = 0;
+        int nextSeparatorIndex = 76;
+        int chunksSoFar = 0;
+        for(i = 0; i < numberTriplets; i++) {
+            dataIndex = i * 3;
+            b1 = binaryData[dataIndex];
+            b2 = binaryData[dataIndex + 1];
+            b3 = binaryData[dataIndex + 2];
+            l = (byte)(b2 & 0xf);
+            k = (byte)(b1 & 3);
+            byte val1 = (b1 & 0xffffff80) != 0 ? (byte)(b1 >> 2 ^ 0xc0) : (byte)(b1
>> 2);
+            byte val2 = (b2 & 0xffffff80) != 0 ? (byte)(b2 >> 4 ^ 0xf0) : (byte)(b2
>> 4);
+            byte val3 = (b3 & 0xffffff80) != 0 ? (byte)(b3 >> 6 ^ 0xfc) : (byte)(b3
>> 6);
+            encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
+            encodedData[encodedIndex + 1] = lookUpBase64Alphabet[val2 | k << 4];
+            encodedData[encodedIndex + 2] = lookUpBase64Alphabet[l << 2 | val3];
+            encodedData[encodedIndex + 3] = lookUpBase64Alphabet[b3 & 0x3f];
+            encodedIndex += 4;
+            if(isChunked && encodedIndex == nextSeparatorIndex) {
+                System.arraycopy(CHUNK_SEPARATOR, 0, encodedData, encodedIndex, CHUNK_SEPARATOR.length);
+                chunksSoFar++;
+                nextSeparatorIndex = 76 * (chunksSoFar + 1) + chunksSoFar * CHUNK_SEPARATOR.length;
+                encodedIndex += CHUNK_SEPARATOR.length;
+            }
+        }
+
+        dataIndex = i * 3;
+        if(fewerThan24bits == 8) {
+            b1 = binaryData[dataIndex];
+            k = (byte)(b1 & 3);
+            byte val1 = (b1 & 0xffffff80) != 0 ? (byte)(b1 >> 2 ^ 0xc0) : (byte)(b1
>> 2);
+            encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
+            encodedData[encodedIndex + 1] = lookUpBase64Alphabet[k << 4];
+            encodedData[encodedIndex + 2] = 61;
+            encodedData[encodedIndex + 3] = 61;
+        } else
+        if(fewerThan24bits == 16) {
+            b1 = binaryData[dataIndex];
+            b2 = binaryData[dataIndex + 1];
+            l = (byte)(b2 & 0xf);
+            k = (byte)(b1 & 3);
+            byte val1 = (b1 & 0xffffff80) != 0 ? (byte)(b1 >> 2 ^ 0xc0) : (byte)(b1
>> 2);
+            byte val2 = (b2 & 0xffffff80) != 0 ? (byte)(b2 >> 4 ^ 0xf0) : (byte)(b2
>> 4);
+            encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
+            encodedData[encodedIndex + 1] = lookUpBase64Alphabet[val2 | k << 4];
+            encodedData[encodedIndex + 2] = lookUpBase64Alphabet[l << 2];
+            encodedData[encodedIndex + 3] = 61;
+        }
+        if(isChunked && chunksSoFar < nbrChunks)
+            System.arraycopy(CHUNK_SEPARATOR, 0, encodedData, encodedDataLength - CHUNK_SEPARATOR.length,
CHUNK_SEPARATOR.length);
+        return encodedData;
+    }
+
+    public static byte[] decodeBase64(byte base64Data[]) {
+        base64Data = discardNonBase64(base64Data);
+        if(base64Data.length == 0)
+            return new byte[0];
+        int numberQuadruple = base64Data.length / 4;
+        byte decodedData[] = null;
+        byte b1 = 0;
+        byte b2 = 0;
+        byte b3 = 0;
+        byte b4 = 0;
+        byte marker0 = 0;
+        byte marker1 = 0;
+        int encodedIndex = 0;
+        int dataIndex = 0;
+        int lastData;
+        for(lastData = base64Data.length; base64Data[lastData - 1] == 61;)
+            if(--lastData == 0)
+                return new byte[0];
+
+        decodedData = new byte[lastData - numberQuadruple];
+        for(int i = 0; i < numberQuadruple; i++) {
+            dataIndex = i * 4;
+            marker0 = base64Data[dataIndex + 2];
+            marker1 = base64Data[dataIndex + 3];
+            b1 = base64Alphabet[base64Data[dataIndex]];
+            b2 = base64Alphabet[base64Data[dataIndex + 1]];
+            if(marker0 != 61 && marker1 != 61) {
+                b3 = base64Alphabet[marker0];
+                b4 = base64Alphabet[marker1];
+                decodedData[encodedIndex] = (byte)(b1 << 2 | b2 >> 4);
+                decodedData[encodedIndex + 1] = (byte)((b2 & 0xf) << 4 | b3 >>
2 & 0xf);
+                decodedData[encodedIndex + 2] = (byte)(b3 << 6 | b4);
+            } else
+            if(marker0 == 61)
+                decodedData[encodedIndex] = (byte)(b1 << 2 | b2 >> 4);
+            else
+            if(marker1 == 61) {
+                b3 = base64Alphabet[marker0];
+                decodedData[encodedIndex] = (byte)(b1 << 2 | b2 >> 4);
+                decodedData[encodedIndex + 1] = (byte)((b2 & 0xf) << 4 | b3 >>
2 & 0xf);
+            }
+            encodedIndex += 3;
+        }
+
+        return decodedData;
+    }
+
+    static byte[] discardWhitespace(byte data[]) {
+        byte groomedData[] = new byte[data.length];
+        int bytesCopied = 0;
+        int i = 0;
+        do
+            if(i < data.length) {
+                switch(data[i]) {
+                default:
+                    groomedData[bytesCopied++] = data[i];
+                    // fall through
+
+                case 9: // '\t'
+                case 10: // '\n'
+                case 13: // '\r'
+                case 32: // ' '
+                    i++;
+                    break;
+                }
+            } else {
+                byte packedData[] = new byte[bytesCopied];
+                System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
+                return packedData;
+            }
+        while(true);
+    }
+
+    static byte[] discardNonBase64(byte data[]) {
+        byte groomedData[] = new byte[data.length];
+        int bytesCopied = 0;
+        for(int i = 0; i < data.length; i++)
+            if(isBase64(data[i]))
+                groomedData[bytesCopied++] = data[i];
+
+        byte packedData[] = new byte[bytesCopied];
+        System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
+        return packedData;
+    }
+
+    public Object encode(Object pObject)
+        throws Exception {
+        if(!(pObject instanceof byte[]))
+            throw new Exception("Parameter supplied to Base64 encode is not a byte[]");
+        else
+            return encode((byte[])pObject);
+    }
+
+    public byte[] encode(byte pArray[]) {
+        return encodeBase64(pArray, false);
+    }
+
+    static final int CHUNK_SIZE = 76;
+    static final byte CHUNK_SEPARATOR[] = "\r\n".getBytes();
+    static final int BASELENGTH = 255;
+    static final int LOOKUPLENGTH = 64;
+    static final int EIGHTBIT = 8;
+    static final int SIXTEENBIT = 16;
+    static final int TWENTYFOURBITGROUP = 24;
+    static final int FOURBYTE = 4;
+    static final int SIGN = -128;
+    static final byte PAD = 61;
+    private static byte base64Alphabet[];
+    private static byte lookUpBase64Alphabet[];
+
+    static  {
+        base64Alphabet = new byte[255];
+        lookUpBase64Alphabet = new byte[64];
+        int i;
+        for(i = 0; i < 255; i++)
+            base64Alphabet[i] = -1;
+
+        for(i = 90; i >= 65; i--)
+            base64Alphabet[i] = (byte)(i - 65);
+
+        for(i = 122; i >= 97; i--)
+            base64Alphabet[i] = (byte)((i - 97) + 26);
+
+        for(i = 57; i >= 48; i--)
+            base64Alphabet[i] = (byte)((i - 48) + 52);
+
+        base64Alphabet[43] = 62;
+        base64Alphabet[47] = 63;
+        for(i = 0; i <= 25; i++)
+            lookUpBase64Alphabet[i] = (byte)(65 + i);
+
+        i = 26;
+        for(int j = 0; i <= 51; j++) {
+            lookUpBase64Alphabet[i] = (byte)(97 + j);
+            i++;
+        }
+
+        i = 52;
+        for(int j = 0; i <= 61; j++) {
+            lookUpBase64Alphabet[i] = (byte)(48 + j);
+            i++;
+        }
+
+        lookUpBase64Alphabet[62] = 43;
+        lookUpBase64Alphabet[63] = 47;
+    }
+}

Added: turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/impl/UnixCrypt.java
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/impl/UnixCrypt.java?rev=581797&view=auto
==============================================================================
--- turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/impl/UnixCrypt.java (added)
+++ turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/impl/UnixCrypt.java Thu
Oct  4 01:26:18 2007
@@ -0,0 +1,412 @@
+package org.apache.fulcrum.crypto.impl;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import org.apache.fulcrum.crypto.CryptoAlgorithm;
+
+import java.util.Random;
+
+/**
+ * Unix crypt (3) algorithm implementation. The java
+ * implementation was taken from the JetSpeed Portal project
+ * (see org.apache.jetspeed.services.security.ldap.UnixCrypt).
+ *
+ * @author Siegfried Goeschl
+ */
+public class UnixCrypt
+{
+    private static final char saltChars[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./".toCharArray();
+    private static final int ITERATIONS = 16;
+    private static final int con_salt[] = {
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 1, 2, 3,
+        4, 5, 6, 7, 8, 9, 10, 11, 5, 6,
+        7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+        17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+        27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
+        37, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+        41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+        51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+        61, 62, 63, 0, 0, 0, 0, 0
+    };
+    private static final boolean shifts2[] = {
+        false, false, true, true, true, true, true, true, false, true,
+        true, true, true, true, true, false
+    };
+    private static final int skb[][] = {
+        {
+            0, 16, 0x20000000, 0x20000010, 0x10000, 0x10010, 0x20010000, 0x20010010, 2048,
2064,
+            0x20000800, 0x20000810, 0x10800, 0x10810, 0x20010800, 0x20010810, 32, 48, 0x20000020,
0x20000030,
+            0x10020, 0x10030, 0x20010020, 0x20010030, 2080, 2096, 0x20000820, 0x20000830,
0x10820, 0x10830,
+            0x20010820, 0x20010830, 0x80000, 0x80010, 0x20080000, 0x20080010, 0x90000, 0x90010,
0x20090000, 0x20090010,
+            0x80800, 0x80810, 0x20080800, 0x20080810, 0x90800, 0x90810, 0x20090800, 0x20090810,
0x80020, 0x80030,
+            0x20080020, 0x20080030, 0x90020, 0x90030, 0x20090020, 0x20090030, 0x80820, 0x80830,
0x20080820, 0x20080830,
+            0x90820, 0x90830, 0x20090820, 0x20090830
+        }, {
+            0, 0x2000000, 8192, 0x2002000, 0x200000, 0x2200000, 0x202000, 0x2202000, 4, 0x2000004,
+            8196, 0x2002004, 0x200004, 0x2200004, 0x202004, 0x2202004, 1024, 0x2000400, 9216,
0x2002400,
+            0x200400, 0x2200400, 0x202400, 0x2202400, 1028, 0x2000404, 9220, 0x2002404, 0x200404,
0x2200404,
+            0x202404, 0x2202404, 0x10000000, 0x12000000, 0x10002000, 0x12002000, 0x10200000,
0x12200000, 0x10202000, 0x12202000,
+            0x10000004, 0x12000004, 0x10002004, 0x12002004, 0x10200004, 0x12200004, 0x10202004,
0x12202004, 0x10000400, 0x12000400,
+            0x10002400, 0x12002400, 0x10200400, 0x12200400, 0x10202400, 0x12202400, 0x10000404,
0x12000404, 0x10002404, 0x12002404,
+            0x10200404, 0x12200404, 0x10202404, 0x12202404
+        }, {
+            0, 1, 0x40000, 0x40001, 0x1000000, 0x1000001, 0x1040000, 0x1040001, 2, 3,
+            0x40002, 0x40003, 0x1000002, 0x1000003, 0x1040002, 0x1040003, 512, 513, 0x40200,
0x40201,
+            0x1000200, 0x1000201, 0x1040200, 0x1040201, 514, 515, 0x40202, 0x40203, 0x1000202,
0x1000203,
+            0x1040202, 0x1040203, 0x8000000, 0x8000001, 0x8040000, 0x8040001, 0x9000000,
0x9000001, 0x9040000, 0x9040001,
+            0x8000002, 0x8000003, 0x8040002, 0x8040003, 0x9000002, 0x9000003, 0x9040002,
0x9040003, 0x8000200, 0x8000201,
+            0x8040200, 0x8040201, 0x9000200, 0x9000201, 0x9040200, 0x9040201, 0x8000202,
0x8000203, 0x8040202, 0x8040203,
+            0x9000202, 0x9000203, 0x9040202, 0x9040203
+        }, {
+            0, 0x100000, 256, 0x100100, 8, 0x100008, 264, 0x100108, 4096, 0x101000,
+            4352, 0x101100, 4104, 0x101008, 4360, 0x101108, 0x4000000, 0x4100000, 0x4000100,
0x4100100,
+            0x4000008, 0x4100008, 0x4000108, 0x4100108, 0x4001000, 0x4101000, 0x4001100,
0x4101100, 0x4001008, 0x4101008,
+            0x4001108, 0x4101108, 0x20000, 0x120000, 0x20100, 0x120100, 0x20008, 0x120008,
0x20108, 0x120108,
+            0x21000, 0x121000, 0x21100, 0x121100, 0x21008, 0x121008, 0x21108, 0x121108, 0x4020000,
0x4120000,
+            0x4020100, 0x4120100, 0x4020008, 0x4120008, 0x4020108, 0x4120108, 0x4021000,
0x4121000, 0x4021100, 0x4121100,
+            0x4021008, 0x4121008, 0x4021108, 0x4121108
+        }, {
+            0, 0x10000000, 0x10000, 0x10010000, 4, 0x10000004, 0x10004, 0x10010004, 0x20000000,
0x30000000,
+            0x20010000, 0x30010000, 0x20000004, 0x30000004, 0x20010004, 0x30010004, 0x100000,
0x10100000, 0x110000, 0x10110000,
+            0x100004, 0x10100004, 0x110004, 0x10110004, 0x20100000, 0x30100000, 0x20110000,
0x30110000, 0x20100004, 0x30100004,
+            0x20110004, 0x30110004, 4096, 0x10001000, 0x11000, 0x10011000, 4100, 0x10001004,
0x11004, 0x10011004,
+            0x20001000, 0x30001000, 0x20011000, 0x30011000, 0x20001004, 0x30001004, 0x20011004,
0x30011004, 0x101000, 0x10101000,
+            0x111000, 0x10111000, 0x101004, 0x10101004, 0x111004, 0x10111004, 0x20101000,
0x30101000, 0x20111000, 0x30111000,
+            0x20101004, 0x30101004, 0x20111004, 0x30111004
+        }, {
+            0, 0x8000000, 8, 0x8000008, 1024, 0x8000400, 1032, 0x8000408, 0x20000, 0x8020000,
+            0x20008, 0x8020008, 0x20400, 0x8020400, 0x20408, 0x8020408, 1, 0x8000001, 9,
0x8000009,
+            1025, 0x8000401, 1033, 0x8000409, 0x20001, 0x8020001, 0x20009, 0x8020009, 0x20401,
0x8020401,
+            0x20409, 0x8020409, 0x2000000, 0xa000000, 0x2000008, 0xa000008, 0x2000400, 0xa000400,
0x2000408, 0xa000408,
+            0x2020000, 0xa020000, 0x2020008, 0xa020008, 0x2020400, 0xa020400, 0x2020408,
0xa020408, 0x2000001, 0xa000001,
+            0x2000009, 0xa000009, 0x2000401, 0xa000401, 0x2000409, 0xa000409, 0x2020001,
0xa020001, 0x2020009, 0xa020009,
+            0x2020401, 0xa020401, 0x2020409, 0xa020409
+        }, {
+            0, 256, 0x80000, 0x80100, 0x1000000, 0x1000100, 0x1080000, 0x1080100, 16, 272,
+            0x80010, 0x80110, 0x1000010, 0x1000110, 0x1080010, 0x1080110, 0x200000, 0x200100,
0x280000, 0x280100,
+            0x1200000, 0x1200100, 0x1280000, 0x1280100, 0x200010, 0x200110, 0x280010, 0x280110,
0x1200010, 0x1200110,
+            0x1280010, 0x1280110, 512, 768, 0x80200, 0x80300, 0x1000200, 0x1000300, 0x1080200,
0x1080300,
+            528, 784, 0x80210, 0x80310, 0x1000210, 0x1000310, 0x1080210, 0x1080310, 0x200200,
0x200300,
+            0x280200, 0x280300, 0x1200200, 0x1200300, 0x1280200, 0x1280300, 0x200210, 0x200310,
0x280210, 0x280310,
+            0x1200210, 0x1200310, 0x1280210, 0x1280310
+        }, {
+            0, 0x4000000, 0x40000, 0x4040000, 2, 0x4000002, 0x40002, 0x4040002, 8192, 0x4002000,
+            0x42000, 0x4042000, 8194, 0x4002002, 0x42002, 0x4042002, 32, 0x4000020, 0x40020,
0x4040020,
+            34, 0x4000022, 0x40022, 0x4040022, 8224, 0x4002020, 0x42020, 0x4042020, 8226,
0x4002022,
+            0x42022, 0x4042022, 2048, 0x4000800, 0x40800, 0x4040800, 2050, 0x4000802, 0x40802,
0x4040802,
+            10240, 0x4002800, 0x42800, 0x4042800, 10242, 0x4002802, 0x42802, 0x4042802, 2080,
0x4000820,
+            0x40820, 0x4040820, 2082, 0x4000822, 0x40822, 0x4040822, 10272, 0x4002820, 0x42820,
0x4042820,
+            10274, 0x4002822, 0x42822, 0x4042822
+        }
+    };
+    private static final int SPtrans[][] = {
+        {
+            0x820200, 0x20000, 0x80800000, 0x80820200, 0x800000, 0x80020200, 0x80020000,
0x80800000, 0x80020200, 0x820200,
+            0x820000, 0x80000200, 0x80800200, 0x800000, 0, 0x80020000, 0x20000, 0x80000000,
0x800200, 0x20200,
+            0x80820200, 0x820000, 0x80000200, 0x800200, 0x80000000, 512, 0x20200, 0x80820000,
512, 0x80800200,
+            0x80820000, 0, 0, 0x80820200, 0x800200, 0x80020000, 0x820200, 0x20000, 0x80000200,
0x800200,
+            0x80820000, 512, 0x20200, 0x80800000, 0x80020200, 0x80000000, 0x80800000, 0x820000,
0x80820200, 0x20200,
+            0x820000, 0x80800200, 0x800000, 0x80000200, 0x80020000, 0, 0x20000, 0x800000,
0x80800200, 0x820200,
+            0x80000000, 0x80820000, 512, 0x80020200
+        }, {
+            0x10042004, 0, 0x42000, 0x10040000, 0x10000004, 8196, 0x10002000, 0x42000, 8192,
0x10040004,
+            4, 0x10002000, 0x40004, 0x10042000, 0x10040000, 4, 0x40000, 0x10002004, 0x10040004,
8192,
+            0x42004, 0x10000000, 0, 0x40004, 0x10002004, 0x42004, 0x10042000, 0x10000004,
0x10000000, 0x40000,
+            8196, 0x10042004, 0x40004, 0x10042000, 0x10002000, 0x42004, 0x10042004, 0x40004,
0x10000004, 0,
+            0x10000000, 8196, 0x40000, 0x10040004, 8192, 0x10000000, 0x42004, 0x10002004,
0x10042000, 8192,
+            0, 0x10000004, 4, 0x10042004, 0x42000, 0x10040000, 0x10040004, 0x40000, 8196,
0x10002000,
+            0x10002004, 4, 0x10040000, 0x42000
+        }, {
+            0x41000000, 0x1010040, 64, 0x41000040, 0x40010000, 0x1000000, 0x41000040, 0x10040,
0x1000040, 0x10000,
+            0x1010000, 0x40000000, 0x41010040, 0x40000040, 0x40000000, 0x41010000, 0, 0x40010000,
0x1010040, 64,
+            0x40000040, 0x41010040, 0x10000, 0x41000000, 0x41010000, 0x1000040, 0x40010040,
0x1010000, 0x10040, 0,
+            0x1000000, 0x40010040, 0x1010040, 64, 0x40000000, 0x10000, 0x40000040, 0x40010000,
0x1010000, 0x41000040,
+            0, 0x1010040, 0x10040, 0x41010000, 0x40010000, 0x1000000, 0x41010040, 0x40000000,
0x40010040, 0x41000000,
+            0x1000000, 0x41010040, 0x10000, 0x1000040, 0x41000040, 0x10040, 0x1000040, 0,
0x41010000, 0x40000040,
+            0x41000000, 0x40010040, 64, 0x1010000
+        }, {
+            0x100402, 0x4000400, 2, 0x4100402, 0, 0x4100000, 0x4000402, 0x100002, 0x4100400,
0x4000002,
+            0x4000000, 1026, 0x4000002, 0x100402, 0x100000, 0x4000000, 0x4100002, 0x100400,
1024, 2,
+            0x100400, 0x4000402, 0x4100000, 1024, 1026, 0, 0x100002, 0x4100400, 0x4000400,
0x4100002,
+            0x4100402, 0x100000, 0x4100002, 1026, 0x100000, 0x4000002, 0x100400, 0x4000400,
2, 0x4100000,
+            0x4000402, 0, 1024, 0x100002, 0, 0x4100002, 0x4100400, 1024, 0x4000000, 0x4100402,
+            0x100402, 0x100000, 0x4100402, 2, 0x4000400, 0x100402, 0x100002, 0x100400, 0x4100000,
0x4000402,
+            1026, 0x4000000, 0x4000002, 0x4100400
+        }, {
+            0x2000000, 16384, 256, 0x2004108, 0x2004008, 0x2000100, 16648, 0x2004000, 16384,
8,
+            0x2000008, 16640, 0x2000108, 0x2004008, 0x2004100, 0, 16640, 0x2000000, 16392,
264,
+            0x2000100, 16648, 0, 0x2000008, 8, 0x2000108, 0x2004108, 16392, 0x2004000, 256,
+            264, 0x2004100, 0x2004100, 0x2000108, 16392, 0x2004000, 16384, 8, 0x2000008,
0x2000100,
+            0x2000000, 16640, 0x2004108, 0, 16648, 0x2000000, 256, 16392, 0x2000108, 256,
+            0, 0x2004108, 0x2004008, 0x2004100, 264, 16384, 16640, 0x2004008, 0x2000100,
264,
+            8, 16648, 0x2004000, 0x2000008
+        }, {
+            0x20000010, 0x80010, 0, 0x20080800, 0x80010, 2048, 0x20000810, 0x80000, 2064,
0x20080810,
+            0x80800, 0x20000000, 0x20000800, 0x20000010, 0x20080000, 0x80810, 0x80000, 0x20000810,
0x20080010, 0,
+            2048, 16, 0x20080800, 0x20080010, 0x20080810, 0x20080000, 0x20000000, 2064, 16,
0x80800,
+            0x80810, 0x20000800, 2064, 0x20000000, 0x20000800, 0x80810, 0x20080800, 0x80010,
0, 0x20000800,
+            0x20000000, 2048, 0x20080010, 0x80000, 0x80010, 0x20080810, 0x80800, 16, 0x20080810,
0x80800,
+            0x80000, 0x20000810, 0x20000010, 0x20080000, 0x80810, 0, 2048, 0x20000010, 0x20000810,
0x20080800,
+            0x20080000, 2064, 16, 0x20080010
+        }, {
+            4096, 128, 0x400080, 0x400001, 0x401081, 4097, 4224, 0, 0x400000, 0x400081,
+            129, 0x401000, 1, 0x401080, 0x401000, 129, 0x400081, 4096, 4097, 0x401081,
+            0, 0x400080, 0x400001, 4224, 0x401001, 4225, 0x401080, 1, 4225, 0x401001,
+            128, 0x400000, 4225, 0x401000, 0x401001, 129, 4096, 128, 0x400000, 0x401001,
+            0x400081, 4225, 4224, 0, 128, 0x400001, 1, 0x400080, 0, 0x400081,
+            0x400080, 4224, 129, 4096, 0x401081, 0x400000, 0x401080, 1, 4097, 0x401081,
+            0x400001, 0x401080, 0x401000, 4097
+        }, {
+            0x8200020, 0x8208000, 32800, 0, 0x8008000, 0x200020, 0x8200000, 0x8208020, 32,
0x8000000,
+            0x208000, 32800, 0x208020, 0x8008020, 0x8000020, 0x8200000, 32768, 0x208020,
0x200020, 0x8008000,
+            0x8208020, 0x8000020, 0, 0x208000, 0x8000000, 0x200000, 0x8008020, 0x8200020,
0x200000, 32768,
+            0x8208000, 32, 0x200000, 32768, 0x8000020, 0x8208020, 32800, 0x8000000, 0, 0x208000,
+            0x8200020, 0x8008020, 0x8008000, 0x200020, 0x8208000, 32, 0x200020, 0x8008000,
0x8208020, 0x200000,
+            0x8200000, 0x8000020, 0x208000, 32800, 0x8008020, 0x8200000, 32, 0x8208000, 0x208020,
0,
+            0x8000000, 0x8200020, 32768, 0x208020
+        }
+    };
+    private static final int cov_2char[] = {
+        46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+        56, 57, 65, 66, 67, 68, 69, 70, 71, 72,
+        73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
+        83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
+        99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
+        109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
+        119, 120, 121, 122
+    };
+
+    private UnixCrypt() {}
+    
+    private static final int D_ENCRYPT(int L, int R, int S, int E0, int E1, int s[])
+    {
+        int v = R ^ R >>> 16;
+        int u = v & E0;
+        v &= E1;
+        u = u ^ u << 16 ^ R ^ s[S];
+        int t = v ^ v << 16 ^ R ^ s[S + 1];
+        t = t >>> 4 | t << 28;
+        L ^= SPtrans[1][t & 0x3f] | SPtrans[3][t >>> 8 & 0x3f] | SPtrans[5][t
>>> 16 & 0x3f] | SPtrans[7][t >>> 24 & 0x3f] | SPtrans[0][u &
0x3f] | SPtrans[2][u >>> 8 & 0x3f] | SPtrans[4][u >>> 16 & 0x3f]
| SPtrans[6][u >>> 24 & 0x3f];
+        return L;
+    }
+
+    private static final int HPERM_OP(int a, int n, int m)
+    {
+        int t = (a << 16 - n ^ a) & m;
+        a = a ^ t ^ t >>> 16 - n;
+        return a;
+    }
+
+    private static final void PERM_OP(int a, int b, int n, int m, int results[])
+    {
+        int t = (a >>> n ^ b) & m;
+        a ^= t << n;
+        b ^= t;
+        results[0] = a;
+        results[1] = b;
+    }
+
+    private static final int[] body(int schedule[], int Eswap0, int Eswap1)
+    {
+        int left = 0;
+        int right = 0;
+        int t = 0;
+        for(int j = 0; j < 25; j++)
+        {
+            for(int i = 0; i < 32; i += 4)
+            {
+                left = D_ENCRYPT(left, right, i, Eswap0, Eswap1, schedule);
+                right = D_ENCRYPT(right, left, i + 2, Eswap0, Eswap1, schedule);
+            }
+
+            t = left;
+            left = right;
+            right = t;
+        }
+
+        t = right;
+        right = left >>> 1 | left << 31;
+        left = t >>> 1 | t << 31;
+        left &= 0xffffffff;
+        right &= 0xffffffff;
+        int results[] = new int[2];
+        PERM_OP(right, left, 1, 0x55555555, results);
+        right = results[0];
+        left = results[1];
+        PERM_OP(left, right, 8, 0xff00ff, results);
+        left = results[0];
+        right = results[1];
+        PERM_OP(right, left, 2, 0x33333333, results);
+        right = results[0];
+        left = results[1];
+        PERM_OP(left, right, 16, 65535, results);
+        left = results[0];
+        right = results[1];
+        PERM_OP(right, left, 4, 0xf0f0f0f, results);
+        right = results[0];
+        left = results[1];
+        int out[] = new int[2];
+        out[0] = left;
+        out[1] = right;
+        return out;
+    }
+
+    private static final int byteToUnsigned(byte b)
+    {
+        int value = b;
+        return value < 0 ? value + 256 : value;
+    }
+
+    public static final String crypt(String original)
+    {
+        Random randomGenerator = new Random();
+        int numSaltChars = saltChars.length;
+        String salt = "" + saltChars[Math.abs(randomGenerator.nextInt()) % numSaltChars]
+ saltChars[Math.abs(randomGenerator.nextInt()) % numSaltChars];
+        return crypt(salt, original);
+    }
+
+    public static final String crypt(String salt, String original)
+    {
+        for(; salt.length() < 2; salt = salt + "A");
+        StringBuffer buffer = new StringBuffer("             ");
+        char charZero = salt.charAt(0);
+        char charOne = salt.charAt(1);
+        buffer.setCharAt(0, charZero);
+        buffer.setCharAt(1, charOne);
+        int Eswap0 = con_salt[charZero];
+        int Eswap1 = con_salt[charOne] << 4;
+        byte key[] = new byte[8];
+        for(int i = 0; i < key.length; i++)
+            key[i] = 0;
+
+        for(int i = 0; i < key.length && i < original.length(); i++)
+        {
+            int iChar = original.charAt(i);
+            key[i] = (byte)(iChar << 1);
+        }
+
+        int schedule[] = des_set_key(key);
+        int out[] = body(schedule, Eswap0, Eswap1);
+        byte b[] = new byte[9];
+        intToFourBytes(out[0], b, 0);
+        intToFourBytes(out[1], b, 4);
+        b[8] = 0;
+        int i = 2;
+        int y = 0;
+        int u = 128;
+        for(; i < 13; i++)
+        {
+            int j = 0;
+            int c = 0;
+            for(; j < 6; j++)
+            {
+                c <<= 1;
+                if((b[y] & u) != 0)
+                    c |= 0x1;
+                u >>>= 1;
+                if(u == 0)
+                {
+                    y++;
+                    u = 128;
+                }
+                buffer.setCharAt(i, (char) cov_2char[c]);
+            }
+
+        }
+
+        return buffer.toString();
+    }
+
+    private static int[] des_set_key(byte key[])
+    {
+        int schedule[] = new int[32];
+        int c = fourBytesToInt(key, 0);
+        int d = fourBytesToInt(key, 4);
+        int results[] = new int[2];
+        PERM_OP(d, c, 4, 0xf0f0f0f, results);
+        d = results[0];
+        c = results[1];
+        c = HPERM_OP(c, -2, 0xcccc0000);
+        d = HPERM_OP(d, -2, 0xcccc0000);
+        PERM_OP(d, c, 1, 0x55555555, results);
+        d = results[0];
+        c = results[1];
+        PERM_OP(c, d, 8, 0xff00ff, results);
+        c = results[0];
+        d = results[1];
+        PERM_OP(d, c, 1, 0x55555555, results);
+        d = results[0];
+        c = results[1];
+        d = (d & 0xff) << 16 | d & 0xff00 | (d & 0xff0000) >>>
16 | (c & 0xf0000000) >>> 4;
+        c &= 0xfffffff;
+        int j = 0;
+        for(int i = 0; i < 16; i++)
+        {
+            if(shifts2[i])
+            {
+                c = c >>> 2 | c << 26;
+                d = d >>> 2 | d << 26;
+            } else
+            {
+                c = c >>> 1 | c << 27;
+                d = d >>> 1 | d << 27;
+            }
+            c &= 0xfffffff;
+            d &= 0xfffffff;
+            int s = skb[0][c & 0x3f] | skb[1][c >>> 6 & 0x3 | c >>>
7 & 0x3c] | skb[2][c >>> 13 & 0xf | c >>> 14 & 0x30] | skb[3][c
>>> 20 & 0x1 | c >>> 21 & 0x6 | c >>> 22 & 0x38];
+            int t = skb[4][d & 0x3f] | skb[5][d >>> 7 & 0x3 | d >>>
8 & 0x3c] | skb[6][d >>> 15 & 0x3f] | skb[7][d >>> 21 & 0xf
| d >>> 22 & 0x30];
+            schedule[j++] = (t << 16 | s & 0xffff) & 0xffffffff;
+            s = s >>> 16 | t & 0xffff0000;
+            s = s << 4 | s >>> 28;
+            schedule[j++] = s & 0xffffffff;
+        }
+
+        return schedule;
+    }
+
+    private static int fourBytesToInt(byte b[], int offset)
+    {
+        int value = byteToUnsigned(b[offset++]);
+        value |= byteToUnsigned(b[offset++]) << 8;
+        value |= byteToUnsigned(b[offset++]) << 16;
+        value |= byteToUnsigned(b[offset++]) << 24;
+        return value;
+    }
+
+    private static final void intToFourBytes(int iValue, byte b[], int offset)
+    {
+        b[offset++] = (byte)(iValue & 0xff);
+        b[offset++] = (byte)(iValue >>> 8 & 0xff);
+        b[offset++] = (byte)(iValue >>> 16 & 0xff);
+        b[offset++] = (byte)(iValue >>> 24 & 0xff);
+    }
+
+    public static final boolean matches(String encryptedPassword, String enteredPassword)
+    {
+        String salt = encryptedPassword.substring(0, 3);
+        String newCrypt = crypt(salt, enteredPassword);
+        return newCrypt.equals(encryptedPassword);
+    }
+
+}

Modified: turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/JavaCrypt.java
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/JavaCrypt.java?rev=581797&r1=581796&r2=581797&view=diff
==============================================================================
--- turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/JavaCrypt.java
(original)
+++ turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/JavaCrypt.java
Thu Oct  4 01:26:18 2007
@@ -23,9 +23,8 @@
 
 import java.security.MessageDigest;
 
-import org.apache.commons.codec.binary.Base64;
-
 import org.apache.fulcrum.crypto.CryptoAlgorithm;
+import org.apache.fulcrum.crypto.impl.Base64;
 
 /**
  * Implements the normal java.security.MessageDigest stream cipers.

Modified: turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/OldJavaCrypt.java
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/OldJavaCrypt.java?rev=581797&r1=581796&r2=581797&view=diff
==============================================================================
--- turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/OldJavaCrypt.java
(original)
+++ turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/OldJavaCrypt.java
Thu Oct  4 01:26:18 2007
@@ -21,12 +21,10 @@
  */
 
 
-import javax.mail.internet.MimeUtility;
 import java.security.MessageDigest;
-import java.io.OutputStream;
-import java.io.ByteArrayOutputStream;
 
 import org.apache.fulcrum.crypto.CryptoAlgorithm;
+import org.apache.fulcrum.crypto.impl.Base64;
 
 /**
  * This is the Message Digest Implementation of Turbine 2.1. It does
@@ -116,10 +114,12 @@
         // default encoding. Thanks to SGawin for spotting this.
 
         byte[] digest = md.digest(value.getBytes("UTF-8"));
-        ByteArrayOutputStream bas =
-            new ByteArrayOutputStream(digest.length + digest.length / 3 + 1);
-        OutputStream encodedStream = MimeUtility.encode(bas, "base64");
-        encodedStream.write(digest);
-        return bas.toString();
+        byte[] base64 = Base64.encodeBase64(digest);
+        // from MD5 the digest has 16 bytes but for SHA1 it contains 20 bytes
+        // depending on the digest lenght the result is truncated
+        int len = (digest.length == 16 ? 20 : 24 );
+        byte[] result = new byte[len];
+        System.arraycopy(base64, 0, result, 0, result.length);
+        return new String(result);
     }
 }

Modified: turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/UnixCrypt.java
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/UnixCrypt.java?rev=581797&r1=581796&r2=581797&view=diff
==============================================================================
--- turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/UnixCrypt.java
(original)
+++ turbine/fulcrum/trunk/crypto/src/java/org/apache/fulcrum/crypto/provider/UnixCrypt.java
Thu Oct  4 01:26:18 2007
@@ -1,6 +1,5 @@
 package org.apache.fulcrum.crypto.provider;
 
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
@@ -23,6 +22,8 @@
 
 import org.apache.fulcrum.crypto.CryptoAlgorithm;
 
+import java.util.Random;
+
 /**
  * Implements Standard Unix crypt(3) for use with the Crypto Service.
  *
@@ -83,18 +84,15 @@
      * encrypt the supplied string with the requested cipher
      *
      * @param value       The value to be encrypted
-     *
      * @return The encrypted value
-     *
      * @throws Exception An Exception of the underlying implementation.
      */
-
     public String encrypt(String value)
         throws Exception
     {
         if (seed == null)
         {
-            java.util.Random randomGenerator = new java.util.Random();
+            Random randomGenerator = new java.util.Random();
             int numSaltChars = SALT_CHARS.length;
 
             seed = (new StringBuffer())
@@ -105,7 +103,6 @@
                 .toString();
         }
 
-        /* UnixCrypt seems to be a really widespread name... */
-        return new cryptix.tools.UnixCrypt(seed).crypt(value);
+        return org.apache.fulcrum.crypto.impl.UnixCrypt.crypt(seed, value);
     }
 }

Modified: turbine/fulcrum/trunk/crypto/xdocs/changes.xml
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/crypto/xdocs/changes.xml?rev=581797&r1=581796&r2=581797&view=diff
==============================================================================
--- turbine/fulcrum/trunk/crypto/xdocs/changes.xml (original)
+++ turbine/fulcrum/trunk/crypto/xdocs/changes.xml Thu Oct  4 01:26:18 2007
@@ -26,6 +26,13 @@
   <body>
     <release version="1.0.6-dev" date="as in SVN">
       <action dev="sgoeschl" type="update">
+        Getting rid of all external dependencies - in particular
+        the crytptix library. The cryptix library contains strong
+        encyryption algorithm causing problems using the software
+        outside of the US (ECCN). Copy and wasted some source from
+        JetSpeed (UnixCrpyt) and commons-codec (Base64).
+      </action>
+      <action dev="sgoeschl" type="update">
         Upgrading to javamail-1.3.2
       </action>
     </release>

Modified: turbine/fulcrum/trunk/crypto/xdocs/index.xml
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/crypto/xdocs/index.xml?rev=581797&r1=581796&r2=581797&view=diff
==============================================================================
--- turbine/fulcrum/trunk/crypto/xdocs/index.xml (original)
+++ turbine/fulcrum/trunk/crypto/xdocs/index.xml Thu Oct  4 01:26:18 2007
@@ -30,8 +30,7 @@
   <section name="Overview">
     <p>
       The Crypto Service allows an application to request various encryption
-      algorithms provided by the normal Java crypto providers and 3rd party
-      providers such as <a href="http://www.cryptix.org/">Cryptix</a>.
+      algorithms.
     </p>
 
     <p>
@@ -144,8 +143,7 @@
     <b>UnixCrypt</b> (org.apache.fulcrum.crypto.provider.UnixCrypt). This is
an
     implementation of the Unix crypt(3) algorithm. Its main use is when
     you need to access legacy information or databases which already
-    contain crypted passwords. UnixCrypt needs the cryptix32.jar from <a
-    href="http://www.cryptix.org/">Cryptix</a>.
+    contain crypted passwords.
     </li>
     <li>
     <b>JavaCrypt</b> (org.apache.fulcrum.crypto.provider.JavaCrypt).  This is
the



Mime
View raw message