Consolidate idea into a single C file.

1 files changed, 285 insertions, 36 deletions

diff --git a/src/lib/libcrypto/idea/i_skey.c b/src/lib/libcrypto/idea/idea.c
index ad349bba57..809283b3c9 100644
--- a/src/lib/libcrypto/idea/i_skey.c
+++ b/src/lib/libcrypto/idea/idea.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: i_skey.c,v 1.7 2023/07/08 10:44:00 beck Exp $ */
+/* $OpenBSD: idea.c,v 1.1 2024/03/29 05:23:50 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -47,7 +47,7 @@
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * OUT OF THE USE OF THIS  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  * The licence and distribution terms for any publically available version or
@@ -56,11 +56,292 @@
  * [including the GNU Public Licence.]
  */
 
-#include <openssl/crypto.h>
 #include <openssl/idea.h>
 #include "idea_local.h"
 
-static IDEA_INT inverse(unsigned int xin);
+void
+idea_cbc_encrypt(const unsigned char *in, unsigned char *out, long length,
+    IDEA_KEY_SCHEDULE *ks, unsigned char *iv, int encrypt)
+{
+        unsigned long tin0, tin1;
+        unsigned long tout0, tout1, xor0, xor1;
+        long l = length;
+        unsigned long tin[2];
+
+        if (encrypt) {
+                n2l(iv, tout0);
+                n2l(iv, tout1);
+                iv -= 8;
+                for (l -= 8; l >= 0; l -= 8)
+                {
+                        n2l(in, tin0);
+                        n2l(in, tin1);
+                        tin0 ^= tout0;
+                        tin1 ^= tout1;
+                        tin[0] = tin0;
+                        tin[1] = tin1;
+                        idea_encrypt(tin, ks);
+                        tout0 = tin[0];
+                        l2n(tout0, out);
+                        tout1 = tin[1];
+                        l2n(tout1, out);
+                }
+                if (l != -8) {
+                        n2ln(in, tin0, tin1, l + 8);
+                        tin0 ^= tout0;
+                        tin1 ^= tout1;
+                        tin[0] = tin0;
+                        tin[1] = tin1;
+                        idea_encrypt(tin, ks);
+                        tout0 = tin[0];
+                        l2n(tout0, out);
+                        tout1 = tin[1];
+                        l2n(tout1, out);
+                }
+                l2n(tout0, iv);
+                l2n(tout1, iv);
+        } else {
+                n2l(iv, xor0);
+                n2l(iv, xor1);
+                iv -= 8;
+                for (l -= 8; l >= 0; l -= 8)
+                {
+                        n2l(in, tin0);
+                        tin[0] = tin0;
+                        n2l(in, tin1);
+                        tin[1] = tin1;
+                        idea_encrypt(tin, ks);
+                        tout0 = tin[0] ^ xor0;
+                        tout1 = tin[1] ^ xor1;
+                        l2n(tout0, out);
+                        l2n(tout1, out);
+                        xor0 = tin0;
+                        xor1 = tin1;
+                }
+                if (l != -8) {
+                        n2l(in, tin0);
+                        tin[0] = tin0;
+                        n2l(in, tin1);
+                        tin[1] = tin1;
+                        idea_encrypt(tin, ks);
+                        tout0 = tin[0] ^ xor0;
+                        tout1 = tin[1] ^ xor1;
+                        l2nn(tout0, tout1, out, l + 8);
+                        xor0 = tin0;
+                        xor1 = tin1;
+                }
+                l2n(xor0, iv);
+                l2n(xor1, iv);
+        }
+        tin0 = tin1 = tout0 = tout1 = xor0 = xor1 = 0;
+        tin[0] = tin[1] = 0;
+}
+LCRYPTO_ALIAS(idea_cbc_encrypt);
+
+void
+idea_encrypt(unsigned long *d, IDEA_KEY_SCHEDULE *key)
+{
+        IDEA_INT *p;
+        unsigned long x1, x2, x3, x4, t0, t1, ul;
+
+        x2 = d[0];
+        x1 = (x2 >> 16);
+        x4 = d[1];
+        x3 = (x4 >> 16);
+
+        p = &(key->data[0][0]);
+
+        E_IDEA(0);
+        E_IDEA(1);
+        E_IDEA(2);
+        E_IDEA(3);
+        E_IDEA(4);
+        E_IDEA(5);
+        E_IDEA(6);
+        E_IDEA(7);
+
+        x1 &= 0xffff;
+        idea_mul(x1, x1, *p, ul);
+        p++;
+
+        t0 = x3 + *(p++);
+        t1 = x2 + *(p++);
+
+        x4 &= 0xffff;
+        idea_mul(x4, x4, *p, ul);
+
+        d[0] = (t0 & 0xffff)|((x1 & 0xffff) << 16);
+        d[1] = (x4 & 0xffff)|((t1 & 0xffff) << 16);
+}
+LCRYPTO_ALIAS(idea_encrypt);
+
+/* The input and output encrypted as though 64bit cfb mode is being
+ * used.  The extra state information to record how much of the
+ * 64bit block we have used is contained in *num;
+ */
+
+void
+idea_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+    long length, IDEA_KEY_SCHEDULE *schedule,
+    unsigned char *ivec, int *num, int encrypt)
+{
+        unsigned long v0, v1, t;
+        int n = *num;
+        long l = length;
+        unsigned long ti[2];
+        unsigned char *iv, c, cc;
+
+        iv = (unsigned char *)ivec;
+        if (encrypt) {
+                while (l--) {
+                        if (n == 0) {
+                                n2l(iv, v0);
+                                ti[0] = v0;
+                                n2l(iv, v1);
+                                ti[1] = v1;
+                                idea_encrypt((unsigned long *)ti, schedule);
+                                iv = (unsigned char *)ivec;
+                                t = ti[0];
+                                l2n(t, iv);
+                                t = ti[1];
+                                l2n(t, iv);
+                                iv = (unsigned char *)ivec;
+                        }
+                        c = *(in++) ^ iv[n];
+                        *(out++) = c;
+                        iv[n] = c;
+                        n = (n + 1) & 0x07;
+                }
+        } else {
+                while (l--) {
+                        if (n == 0) {
+                                n2l(iv, v0);
+                                ti[0] = v0;
+                                n2l(iv, v1);
+                                ti[1] = v1;
+                                idea_encrypt((unsigned long *)ti, schedule);
+                                iv = (unsigned char *)ivec;
+                                t = ti[0];
+                                l2n(t, iv);
+                                t = ti[1];
+                                l2n(t, iv);
+                                iv = (unsigned char *)ivec;
+                        }
+                        cc = *(in++);
+                        c = iv[n];
+                        iv[n] = cc;
+                        *(out++) = c ^ cc;
+                        n = (n + 1) & 0x07;
+                }
+        }
+        v0 = v1 = ti[0] = ti[1] = t = c = cc = 0;
+        *num = n;
+}
+LCRYPTO_ALIAS(idea_cfb64_encrypt);
+
+void
+idea_ecb_encrypt(const unsigned char *in, unsigned char *out,
+    IDEA_KEY_SCHEDULE *ks)
+{
+        unsigned long l0, l1, d[2];
+
+        n2l(in, l0);
+        d[0] = l0;
+        n2l(in, l1);
+        d[1] = l1;
+        idea_encrypt(d, ks);
+        l0 = d[0];
+        l2n(l0, out);
+        l1 = d[1];
+        l2n(l1, out);
+        l0 = l1 = d[0] = d[1] = 0;
+}
+LCRYPTO_ALIAS(idea_ecb_encrypt);
+
+/*
+ * The input and output encrypted as though 64bit ofb mode is being
+ * used.  The extra state information to record how much of the
+ * 64bit block we have used is contained in *num;
+ */
+void
+idea_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+    long length, IDEA_KEY_SCHEDULE *schedule,
+    unsigned char *ivec, int *num)
+{
+        unsigned long v0, v1, t;
+        int n = *num;
+        long l = length;
+        unsigned char d[8];
+        char *dp;
+        unsigned long ti[2];
+        unsigned char *iv;
+        int save = 0;
+
+        iv = (unsigned char *)ivec;
+        n2l(iv, v0);
+        n2l(iv, v1);
+        ti[0] = v0;
+        ti[1] = v1;
+        dp = (char *)d;
+        l2n(v0, dp);
+        l2n(v1, dp);
+        while (l--) {
+                if (n == 0) {
+                        idea_encrypt((unsigned long *)ti, schedule);
+                        dp = (char *)d;
+                        t = ti[0];
+                        l2n(t, dp);
+                        t = ti[1];
+                        l2n(t, dp);
+                        save++;
+                }
+                *(out++) = *(in++) ^ d[n];
+                n = (n + 1) & 0x07;
+        }
+        if (save) {
+                v0 = ti[0];
+                v1 = ti[1];
+                iv = (unsigned char *)ivec;
+                l2n(v0, iv);
+                l2n(v1, iv);
+        }
+        t = v0 = v1 = ti[0] = ti[1] = 0;
+        *num = n;
+}
+LCRYPTO_ALIAS(idea_ofb64_encrypt);
+
+/* taken directly from the 'paper' I'll have a look at it later */
+static IDEA_INT
+inverse(unsigned int xin)
+{
+        long n1, n2, q, r, b1, b2, t;
+
+        if (xin == 0)
+                b2 = 0;
+        else {
+                n1 = 0x10001;
+                n2 = xin;
+                b2 = 1;
+                b1 = 0;
+
+                do {
+                        r = (n1 % n2);
+                        q = (n1 - r)/n2;
+                        if (r == 0) {
+                                if (b2 < 0)
+                                        b2 = 0x10001 + b2;
+                        } else {
+                                n1 = n2;
+                                n2 = r;
+                                t = b2;
+                                b2 = b1 - q*b2;
+                                b1 = t;
+                        }
+                } while (r != 0);
+        }
+        return ((IDEA_INT)b2);
+}
+
 void
 idea_set_encrypt_key(const unsigned char *key, IDEA_KEY_SCHEDULE *ks)
 {
@@ -135,35 +416,3 @@ idea_set_decrypt_key(IDEA_KEY_SCHEDULE *ek, IDEA_KEY_SCHEDULE *dk)
         tp[50] = t;
 }
 LCRYPTO_ALIAS(idea_set_decrypt_key);
-
-/* taken directly from the 'paper' I'll have a look at it later */
-static IDEA_INT
-inverse(unsigned int xin)
-{
-        long n1, n2, q, r, b1, b2, t;
-
-        if (xin == 0)
-                b2 = 0;
-        else {
-                n1 = 0x10001;
-                n2 = xin;
-                b2 = 1;
-                b1 = 0;
-
-                do {
-                        r = (n1 % n2);
-                        q = (n1 - r)/n2;
-                        if (r == 0) {
-                                if (b2 < 0)
-                                        b2 = 0x10001 + b2;
-                        } else {
-                                n1 = n2;
-                                n2 = r;
-                                t = b2;
-                                b2 = b1 - q*b2;
-                                b1 = t;
-                        }
-                } while (r != 0);
-        }
-        return ((IDEA_INT)b2);
-}