edhoc 1.4.0 → 2.0.0

package/external/libedhoc/externals/Unity/test/tests/test_unity_strings.c

@@ -1,330 +0,0 @@
-/* =========================================================================
-    Unity - A Test Framework for C
-    ThrowTheSwitch.org
-    Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams
-    SPDX-License-Identifier: MIT
-========================================================================= */
-
-#include "unity.h"
-#define TEST_INSTANCES
-#include "self_assessment_utils.h"
-
-static int SetToOneToFailInTearDown;
-static int SetToOneMeanWeAlreadyCheckedThisGuy;
-
-void setUp(void)
-{
-    SetToOneToFailInTearDown = 0;
-    SetToOneMeanWeAlreadyCheckedThisGuy = 0;
-}
-
-void tearDown(void)
-{
-    endPutcharSpy(); /* Stop suppressing test output */
-    if (SetToOneToFailInTearDown == 1)
-    {
-        /* These will be skipped internally if already failed/ignored */
-        TEST_FAIL_MESSAGE("<= Failed in tearDown");
-        TEST_IGNORE_MESSAGE("<= Ignored in tearDown");
-    }
-    if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
-    {
-        UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]");
-        UNITY_OUTPUT_CHAR('\n');
-    }
-}
-
-void testEqualStrings(void)
-{
-    const char *testString = "foo";
-
-    TEST_ASSERT_EQUAL_STRING(testString, testString);
-    TEST_ASSERT_EQUAL_STRING_MESSAGE("foo", "foo", "foo isn't foo");
-    TEST_ASSERT_EQUAL_STRING("foo", testString);
-    TEST_ASSERT_EQUAL_STRING(testString, "foo");
-    TEST_ASSERT_EQUAL_STRING("", "");
-}
-
-void testEqualStringsLen(void)
-{
-    const char *testString = "foobar";
-    TEST_ASSERT_EQUAL_STRING_LEN(testString, testString, strlen(testString));
-    TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE("foobar", "foobaz", 5, "fooba isn't fooba");
-    TEST_ASSERT_EQUAL_STRING_LEN("foo", testString, 3);
-    TEST_ASSERT_EQUAL_STRING_LEN(testString, "foo", 3);
-    TEST_ASSERT_EQUAL_STRING_LEN("", "", 3);
-}
-
-void testEqualStringsWithCarriageReturnsAndLineFeeds(void)
-{
-    const char *testString = "foo\r\nbar";
-
-    TEST_ASSERT_EQUAL_STRING(testString, testString);
-    TEST_ASSERT_EQUAL_STRING("foo\r\nbar", "foo\r\nbar");
-    TEST_ASSERT_EQUAL_STRING("foo\r\nbar", testString);
-    TEST_ASSERT_EQUAL_STRING(testString, "foo\r\nbar");
-    TEST_ASSERT_EQUAL_STRING("", "");
-}
-
-void testNotEqualString1(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING("foo", "bar");
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringLen1(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_LEN("foobar", "foobaz", 6);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString2(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING("foo", "");
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringLen2(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_LEN("foo", "", 3);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString3(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING("", "bar");
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringLen3(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_LEN("", "bar", 3);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString4(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING("bar\r", "bar\n");
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringLen4(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_LEN("ba\r\x16", "ba\r\n", 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString5(void)
-{
-    const char str1[] = { 0x41, 0x42, 0x03, 0x00 };
-    const char str2[] = { 0x41, 0x42, 0x04, 0x00 };
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING(str1, str2);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString_ExpectedStringIsNull(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING(NULL, "bar");
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringLen_ExpectedStringIsNull(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_LEN(NULL, "bar", 1);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString_ActualStringIsNull(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING("foo", NULL);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringLen_ActualStringIsNull(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_LEN("foo", NULL, 1);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString_ExpectedStringIsLonger(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING("foo2", "foo");
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString_ActualStringIsLonger(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING("foo", "foo2");
-    VERIFY_FAILS_END
-}
-
-void testEqualStringArrays(void)
-{
-    const char *testStrings[] = { "foo", "boo", "woo", "moo" };
-    const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
-
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, expStrings, 3);
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 3);
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 2);
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 1);
-}
-
-void testNotEqualStringArray1(void)
-{
-    const char *testStrings[] = { "foo", "boo", "woo", "moo" };
-    const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringArray2(void)
-{
-    const char *testStrings[] = { "zoo", "boo", "woo", "moo" };
-    const char *expStrings[] = { "foo", "boo", "woo", "moo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringArray3(void)
-{
-    const char *testStrings[] = { "foo", "boo", "woo", NULL };
-    const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringArray4(void)
-{
-    const char *testStrings[] = { "foo", "boo", "woo", "moo" };
-    const char *expStrings[] = { "foo", NULL, "woo", "moo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringArray5(void)
-{
-    const char **testStrings = NULL;
-    const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringArray6(void)
-{
-    const char *testStrings[] = { "foo", "boo", "woo", "zoo" };
-    const char **expStrings = NULL;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testEqualStringArrayIfBothNulls(void)
-{
-    const char **testStrings = NULL;
-    const char **expStrings = NULL;
-
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-}
-
-void testNotEqualStringArrayLengthZero(void)
-{
-    const char *testStrings[] = {NULL};
-    const char **expStrings = NULL;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 0);
-    VERIFY_FAILS_END
-}
-
-void testEqualStringEachEqual(void)
-{
-    const char *testStrings1[] = { "foo", "foo", "foo", "foo" };
-    const char *testStrings2[] = { "boo", "boo", "boo", "zoo" };
-    const char *testStrings3[] = { "", "", "", "" };
-
-    TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings1, 4);
-    TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings1, 1);
-    TEST_ASSERT_EACH_EQUAL_STRING("boo", testStrings2, 3);
-    TEST_ASSERT_EACH_EQUAL_STRING("", testStrings3, 4);
-}
-
-void testNotEqualStringEachEqual1(void)
-{
-    const char *testStrings[] = { "foo", "foo", "foo", "moo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringEachEqual2(void)
-{
-    const char *testStrings[] = { "boo", "foo", "foo", "foo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringEachEqual3(void)
-{
-    const char *testStrings[] = { "foo", "foo", "foo", NULL };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringEachEqual4(void)
-{
-    const char *testStrings[] = { "foo", "foo", "woo", "foo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringEachEqual5(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EACH_EQUAL_STRING("foo", NULL, 1);
-    VERIFY_FAILS_END
-}
-
-void testCstringsEscapeSequence(void)
-{
-#ifndef USING_OUTPUT_SPY
-    TEST_IGNORE();
-#else
-    startPutcharSpy();
-    UnityPrint("\x16\x10");
-    endPutcharSpy();
-    TEST_ASSERT_EQUAL_STRING("\\x16\\x10", getBufferPutcharSpy());
-#endif
-}

package/external/libedhoc/externals/Unity/test/tests/types_for_test.h

@@ -1,21 +0,0 @@
-/* =========================================================================
-    Unity - A Test Framework for C
-    ThrowTheSwitch.org
-    Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams
-    SPDX-License-Identifier: MIT
-========================================================================= */
-
-#pragma once
-
-typedef enum {
-    ENUM_A,
-    ENUM_2,
-    ENUM_C,
-    ENUM_4,
-} test_enum_t;
-
-static const float test_arr[] = {
-    1.2f,
-    2.3f,
-    3.4f,
-};

package/external/libedhoc/externals/compact25519/src/c25519/c25519.c

@@ -1,126 +0,0 @@
-/* Curve25519 (Montgomery form)
- * Daniel Beer <dlbeer@gmail.com>, 18 Apr 2014
- *
- * This file is in the public domain.
- */
-
-#include "c25519.h"
-
-#ifndef COMPACT_DISABLE_X25519
-const uint8_t c25519_base_x[F25519_SIZE] = {9};
-
-/* Double an X-coordinate */
-static void xc_double(uint8_t *x3, uint8_t *z3,
-		      const uint8_t *x1, const uint8_t *z1)
-{
-	/* Explicit formulas database: dbl-1987-m
-	 *
-	 * source 1987 Montgomery "Speeding the Pollard and elliptic
-	 *   curve methods of factorization", page 261, fourth display
-	 * compute X3 = (X1^2-Z1^2)^2
-	 * compute Z3 = 4 X1 Z1 (X1^2 + a X1 Z1 + Z1^2)
-	 */
-	uint8_t x1sq[F25519_SIZE];
-	uint8_t z1sq[F25519_SIZE];
-	uint8_t x1z1[F25519_SIZE];
-	uint8_t a[F25519_SIZE];
-
-	f25519_mul__distinct(x1sq, x1, x1);
-	f25519_mul__distinct(z1sq, z1, z1);
-	f25519_mul__distinct(x1z1, x1, z1);
-
-	f25519_sub(a, x1sq, z1sq);
-	f25519_mul__distinct(x3, a, a);
-
-	f25519_mul_c(a, x1z1, 486662);
-	f25519_add(a, x1sq, a);
-	f25519_add(a, z1sq, a);
-	f25519_mul__distinct(x1sq, x1z1, a);
-	f25519_mul_c(z3, x1sq, 4);
-}
-
-/* Differential addition */
-static void xc_diffadd(uint8_t *x5, uint8_t *z5,
-		       const uint8_t *x1, const uint8_t *z1,
-		       const uint8_t *x2, const uint8_t *z2,
-		       const uint8_t *x3, const uint8_t *z3)
-{
-	/* Explicit formulas database: dbl-1987-m3
-	 *
-	 * source 1987 Montgomery "Speeding the Pollard and elliptic curve
-	 *   methods of factorization", page 261, fifth display, plus
-	 *   common-subexpression elimination
-	 * compute A = X2+Z2
-	 * compute B = X2-Z2
-	 * compute C = X3+Z3
-	 * compute D = X3-Z3
-	 * compute DA = D A
-	 * compute CB = C B
-	 * compute X5 = Z1(DA+CB)^2
-	 * compute Z5 = X1(DA-CB)^2
-	 */
-	uint8_t da[F25519_SIZE];
-	uint8_t cb[F25519_SIZE];
-	uint8_t a[F25519_SIZE];
-	uint8_t b[F25519_SIZE];
-
-	f25519_add(a, x2, z2);
-	f25519_sub(b, x3, z3); /* D */
-	f25519_mul__distinct(da, a, b);
-
-	f25519_sub(b, x2, z2);
-	f25519_add(a, x3, z3); /* C */
-	f25519_mul__distinct(cb, a, b);
-
-	f25519_add(a, da, cb);
-	f25519_mul__distinct(b, a, a);
-	f25519_mul__distinct(x5, z1, b);
-
-	f25519_sub(a, da, cb);
-	f25519_mul__distinct(b, a, a);
-	f25519_mul__distinct(z5, x1, b);
-}
-
-void c25519_smult(uint8_t *result, const uint8_t *q, const uint8_t *e)
-{
-	/* Current point: P_m */
-	uint8_t xm[F25519_SIZE];
-	uint8_t zm[F25519_SIZE] = {1};
-
-	/* Predecessor: P_(m-1) */
-	uint8_t xm1[F25519_SIZE] = {1};
-	uint8_t zm1[F25519_SIZE] = {0};
-
-	int i;
-
-	/* Note: bit 254 is assumed to be 1 */
-	f25519_copy(xm, q);
-
-	for (i = 253; i >= 0; i--) {
-		const int bit = (e[i >> 3] >> (i & 7)) & 1;
-		uint8_t xms[F25519_SIZE];
-		uint8_t zms[F25519_SIZE];
-
-		/* From P_m and P_(m-1), compute P_(2m) and P_(2m-1) */
-		xc_diffadd(xm1, zm1, q, f25519_one, xm, zm, xm1, zm1);
-		xc_double(xm, zm, xm, zm);
-
-		/* Compute P_(2m+1) */
-		xc_diffadd(xms, zms, xm1, zm1, xm, zm, q, f25519_one);
-
-		/* Select:
-		 *   bit = 1 --> (P_(2m+1), P_(2m))
-		 *   bit = 0 --> (P_(2m), P_(2m-1))
-		 */
-		f25519_select(xm1, xm1, xm, bit);
-		f25519_select(zm1, zm1, zm, bit);
-		f25519_select(xm, xm, xms, bit);
-		f25519_select(zm, zm, zms, bit);
-	}
-
-	/* Freeze out of projective coordinates */
-	f25519_inv__distinct(zm1, zm);
-	f25519_mul__distinct(result, zm1, xm);
-	f25519_normalize(result);
-}
-#endif

package/external/libedhoc/externals/compact25519/src/c25519/c25519.h

@@ -1,49 +0,0 @@
-/* Curve25519 (Montgomery form)
- * Daniel Beer <dlbeer@gmail.com>, 18 Apr 2014
- *
- * This file is in the public domain.
- */
-
-#ifndef C25519_H_
-#define C25519_H_
-
-#ifndef COMPACT_DISABLE_X25519
-#include <stdint.h>
-#include "f25519.h"
-
-/* Curve25519 has the equation over F(p = 2^255-19):
- *
- *    y^2 = x^3 + 486662x^2 + x
- *
- * 486662 = 4A+2, where A = 121665. This is a Montgomery curve.
- *
- * For more information, see:
- *
- *    Bernstein, D.J. (2006) "Curve25519: New Diffie-Hellman speed
- *    records". Document ID: 4230efdfa673480fc079449d90f322c0.
- */
-
-/* This is the site of a Curve25519 exponent (private key) */
-#define C25519_EXPONENT_SIZE  32
-
-/* Having generated 32 random bytes, you should call this function to
- * finalize the generated key.
- */
-static inline void c25519_prepare(uint8_t *key)
-{
-	key[0] &= 0xf8;
-	key[31] &= 0x7f;
-	key[31] |= 0x40;
-}
-
-/* X-coordinate of the base point */
-extern const uint8_t c25519_base_x[F25519_SIZE];
-
-/* X-coordinate scalar multiply: given the X-coordinate of q, return the
- * X-coordinate of e*q.
- *
- * result and q are field elements. e is an exponent.
- */
-void c25519_smult(uint8_t *result, const uint8_t *q, const uint8_t *e);
-#endif
-#endif