crewID/libfreefare
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rework unit tests using cutter.

Browse source
This commit is contained in:
Romain Tartiere 2010-01-11 20:14:30 +00:00
parent 935ab47c54
commit c1bcb966ea
24 changed files with 675 additions and 2277 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Makefile.am
View file

@ -1,7 +1,9 @@
ACLOCAL_AMFLAGS = -I m4
SUBDIRS = libfreefare
SUBDIRS = libfreefare test
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = libfreefare.pc

11
configure.ac
View file

@ -41,5 +41,14 @@ PKG_CHECK_MODULES([LIBNFC], [libnfc], [], [AC_MSG_ERROR([libnfc is mandatory.])]
PKG_CONFIG_REQUIRES="libnfc"
AC_SUBST([PKG_CONFIG_REQUIRES])
AC_OUTPUT([Makefile examples/Makefile libfreefare/Makefile libfreefare.pc])
m4_ifdef([AC_CHECK_CUTTER], [AC_CHECK_CUTTER], [ac_cv_use_cutter="no"])
AM_CONDITIONAL([WITH_CUTTER], [test "$ac_cv_use_cutter" != "no"])
m4_ifdef([AC_CHECK_COVERAGE], [AC_CHECK_COVERAGE])
if test x$ac_cv_enable_coverage = xyes; then
CFLAGS="$CFLAGS -O0 -fprofile-arcs -ftest-coverage"
fi
AC_OUTPUT([Makefile examples/Makefile libfreefare/Makefile libfreefare.pc test/Makefile])

51
test/Makefile
View file

@ -1,51 +0,0 @@
LMF_SRCDIR= ${.CURDIR}/../libfreefare
.PATH: ${LMF_SRCDIR}
#LMF_SRCS!= ${MAKE} -f ${LMF_SRCDIR}/Makefile -V SRCS
LMF_SRCS= ${LMF_SRCDIR}/mifare_classic.c \
${LMF_SRCDIR}/mad.c \
${LMF_SRCDIR}/mifare_application.c
TESTS= test_read_sector_0.c \
test_authenticate.c \
test_value_block.c \
test_access_bits.c \
test_format.c \
test_create_trailer_block.c \
test_mad.c \
test_mifare_application.c
SRCS= ${LMF_SRCS} \
${TESTS} \
main.c \
mifare_classic_test.c
# list.h must be up-to-date before building main.o
main.o: list.h
NO_MAN=
PROG= libfreefare_test
INTERNALPROG= yes
LDADD+= -lnfc
CFLAGS+= -std=c99
CFLAGS+= -ggdb
CFLAGS+= -Wall -pedantic
CFLAGS+= -I${LMF_SRCDIR} -I. -I..
.PHONY: check test
check test: libfreefare_test
./libfreefare_test
# list.h is just a list of all tests, as indicated by DEFINE_TEST macro lines
list.h: ${TESTS} Makefile
(cd ${.CURDIR}; cat ${TESTS}) | grep DEFINE_TEST > list.h
CLEANFILES+= list.h
cleantest:
-chmod -R +w /tmp/${PROG}.*
-rm -rf /tmp/${PROG}.*
.include <bsd.prog.mk>

31
test/Makefile.am Normal file
View file

@ -0,0 +1,31 @@
# $Id$
TESTS = run-test.sh
TESTS_ENVIRONMENT = NO_MAKE=yes CUTTER="$(CUTTER)"
noinst_LTLIBRARIES = \
test_mad.la \
test_mifare_classic.la \
test_mifare_classic_create_trailer_block.la \
test_mifare_classic_application.la
INCLUDES = $(CUTTER_CFLAGS) -I$(top_srcdir)/libfreefare
LIBS = $(CUTTER_LIBS)
AM_LDFLAGS = -module -rpath $(libdir) -avoid-version -no-undefined
test_mad_la_SOURCES = test_mad.c
test_mad_la_LIBADD = $(top_srcdir)/libfreefare/libfreefare.la
test_mifare_classic_la_SOURCES = test_mifare_classic.c \
mifare_classic_fixture.c
test_mifare_classic_la_LIBADD = $(top_srcdir)/libfreefare/libfreefare.la
test_mifare_classic_create_trailer_block_la_SOURCES = test_mifare_classic_create_trailer_block.c
test_mifare_classic_create_trailer_block_la_LIBADD = $(top_srcdir)/libfreefare/libfreefare.la
test_mifare_classic_application_la_SOURCES = test_mifare_classic_application.c
test_mifare_classic_application_la_LIBADD = $(top_srcdir)/libfreefare/libfreefare.la
echo-cutter:
@echo $(CUTTER)

1235
test/main.c
View file

File diff suppressed because it is too large Load diff

39
test/mifare_classic_fixture.c Normal file
View file

@ -0,0 +1,39 @@
#include <cutter.h>
#include <freefare.h>
static nfc_device_t *device = NULL;
static MifareClassicTag *tags = NULL;
MifareClassicTag tag = NULL;
void
setup ()
{
int res;
device = nfc_connect (NULL);
cut_assert_not_null (device, "No device found");
tags = mifare_classic_get_tags (device);
cut_assert_not_null (tags ,"Error enumerating NFC tags");
cut_assert_not_null (tags[0], "No tag on NFC device");
tag = tags[0];
res = mifare_classic_connect (tag);
cut_assert_equal_int (0, res);
}
void
teardown ()
{
if (tag)
mifare_classic_disconnect (tag);
if (tags)
mifare_classic_free_tags (tags);
if (device)
nfc_disconnect (device);
}

2
test/mifare_classic_fixture.h Normal file
View file

@ -0,0 +1,2 @@
extern MifareClassicTag tag;

85
test/mifare_classic_test.c
View file

@ -1,85 +0,0 @@
#include "test.h"
static nfc_device_t *device = NULL;
static MifareClassicTag *tags = NULL;
int
mifare_classic_test_setup (MifareClassicTag *tag)
{
int res = 0;
*tag = NULL;
device = nfc_connect (NULL);
if (!device)
res = -1;
if (0 == res) {
tags = mifare_classic_get_tags (device);
if (!tags) {
nfc_disconnect (device);
device = NULL;
res = -2;
}
}
if (0 == res) {
if (!tags[0]) {
mifare_classic_free_tags (tags);
tags = NULL;
nfc_disconnect (device);
device = NULL;
res = -4;
}
}
if (0 == res) {
*tag = tags[0];
res = mifare_classic_connect (*tag);
if (res != 0) {
mifare_classic_disconnect (*tag);
nfc_disconnect (device);
*tag = NULL;
device = NULL;
res = -3;
}
}
return res;
}
int
mifare_classic_test_teardown (MifareClassicTag tag)
{
int res;
if (tag)
res = mifare_classic_disconnect (tag);
if (0 == res) {
if (tags)
mifare_classic_free_tags (tags);
if (device)
nfc_disconnect (device);
}
return res;
}
int
read_data_block (char *filename, MifareClassicBlock *block)
{
FILE *f = fopen (filename, "r");
if (f == NULL)
return -1;
char buffer[17];
fgets(buffer, 17, f);
memcpy (block, buffer, 16);
fclose (f);
return 0;
}

4
test/null_value_block.uu
View file

@ -1,4 +0,0 @@
begin 644 null_value_block
0`````/____\``````/\`_P``
`
end

13
test/run-test.sh Executable file
View file

@ -0,0 +1,13 @@
#!/bin/sh
export BASE_DIR="`dirname $0`"
if test -z "$NO_MAKE"; then
make -C "$BASE_DIR/../" > /dev/null || exit 1
fi
if test -z "$CUTTER"; then
CUTTER="`make -s -C "$BASE_DIR" echo-cutter`"
fi
"$CUTTER" -s "$BASE_DIR" "$@" "$BASE_DIR"

4
test/sample_value_block.uu
View file

@ -1,4 +0,0 @@
begin 644 sample_value_block
0Z`,``!?\___H`P```/\`_P``
`
end

211
test/test.h
View file

@ -1,211 +0,0 @@
/*
* Copyright (c) 2003-2006 Tim Kientzle
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 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 SUCH DAMAGE.
*
* $FreeBSD$
*/
/* Every test program should #include "test.h" as the first thing. */
/*
* The goal of this file (and the matching test.c) is to
* simplify the very repetitive test-*.c test programs.
*/
#if 0
#if defined(HAVE_CONFIG_H)
/* Most POSIX platforms use the 'configure' script to build config.h */
#include "config.h"
#elif defined(__FreeBSD__)
/* Building as part of FreeBSD system requires a pre-built config.h. */
#include "config_freebsd.h"
#elif defined(_WIN32) && !defined(__CYGWIN__)
/* Win32 can't run the 'configure' script. */
#include "config_windows.h"
#else
/* Warn if the library hasn't been (automatically or manually) configured. */
#error Oops: No config.h and no pre-built configuration in test.h.
#endif
#endif
#if !defined(_WIN32) || defined(__CYGWIN__)
#include <dirent.h>
#else
#include <direct.h>
#endif
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#if !defined(_WIN32) || defined(__CYGWIN__)
#include <unistd.h>
#endif
#include <wchar.h>
#ifdef USE_DMALLOC
#include <dmalloc.h>
#endif
/* No non-FreeBSD platform will have __FBSDID, so just define it here. */
#ifdef __FreeBSD__
#include <sys/cdefs.h> /* For __FBSDID */
#else
/* Some non-FreeBSD platforms such as newlib-derived ones like
* cygwin, have __FBSDID, so this definition must be guarded.
*/
#ifndef __FBSDID
#define __FBSDID(a) /* null */
#endif
#endif
#if defined(_WIN32) && !defined(__CYGWIN__)
#define snprintf sprintf_s
#define LOCALE_DE "deu"
#else
#define LOCALE_DE "de_DE.UTF-8"
#endif
#ifndef O_BINARY
#define O_BINARY 0
#endif
/*
* Redefine DEFINE_TEST for use in defining the test functions.
*/
#undef DEFINE_TEST
#define DEFINE_TEST(name) void name(void); void name(void)
/* An implementation of the standard assert() macro */
#define assert(e) test_assert(__FILE__, __LINE__, (e), #e, NULL)
/* Assert two integers are the same. Reports value of each one if not. */
#define assertEqualInt(v1,v2) \
if (!(test_assert_equal_int(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL))) break; do {} while (0)
/* Assert two strings are the same. Reports value of each one if not. */
#define assertEqualString(v1,v2) \
if (!(test_assert_equal_string(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL))) break; do {} while (0)
/* As above, but v1 and v2 are wchar_t * */
#define assertEqualWString(v1,v2) \
if (!(test_assert_equal_wstring(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL))) break; do {} while (0)
/* As above, but raw blocks of bytes. */
#define assertEqualMem(v1, v2, l) \
if (!(test_assert_equal_mem(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (l), #l, NULL))) break; do {} while (0)
/* Assert two files are the same; allow printf-style expansion of second name.
* See below for comments about variable arguments here...
*/
#define assertEqualFile \
test_setup(__FILE__, __LINE__);test_assert_equal_file
/* Assert that a file is empty; supports printf-style arguments. */
#define assertEmptyFile \
test_setup(__FILE__, __LINE__);test_assert_empty_file
/* Assert that a file exists; supports printf-style arguments. */
#define assertFileExists \
test_setup(__FILE__, __LINE__);test_assert_file_exists
/* Assert that a file exists; supports printf-style arguments. */
#define assertFileNotExists \
test_setup(__FILE__, __LINE__);test_assert_file_not_exists
/* Assert that file contents match a string; supports printf-style arguments. */
#define assertFileContents \
test_setup(__FILE__, __LINE__);test_assert_file_contents
/*
* This would be simple with C99 variadic macros, but I don't want to
* require that. Instead, I insert a function call before each
* skipping() call to pass the file and line information down. Crude,
* but effective.
*/
#define skipping \
test_setup(__FILE__, __LINE__);test_skipping
/* Function declarations. These are defined in test_utility.c. */
void failure(const char *fmt, ...);
void test_setup(const char *, int);
void test_skipping(const char *fmt, ...);
int test_assert(const char *, int, int, const char *, void *);
int test_assert_empty_file(const char *, ...);
int test_assert_equal_file(const char *, const char *, ...);
int test_assert_equal_int(const char *, int, int, const char *, int, const char *, void *);
int test_assert_equal_string(const char *, int, const char *v1, const char *, const char *v2, const char *, void *);
int test_assert_equal_wstring(const char *, int, const wchar_t *v1, const char *, const wchar_t *v2, const char *, void *);
int test_assert_equal_mem(const char *, int, const void *, const char *, const void *, const char *, size_t, const char *, void *);
int test_assert_file_contents(const void *, int, const char *, ...);
int test_assert_file_exists(const char *, ...);
int test_assert_file_not_exists(const char *, ...);
/* Like sprintf, then system() */
int systemf(const char * fmt, ...);
/* Suck file into string allocated via malloc(). Call free() when done. */
/* Supports printf-style args: slurpfile(NULL, "%s/myfile", refdir); */
char *slurpfile(size_t *, const char *fmt, ...);
/* Extracts named reference file to the current directory. */
void extract_reference_file(const char *);
/* Get external gzip program name */
const char *external_gzip_program(int un);
#if 0
/*
* Special interfaces for libarchive test harness.
*/
#include "archive.h"
#include "archive_entry.h"
/* Special customized read-from-memory interface. */
int read_open_memory(struct archive *, void *, size_t, size_t);
/* "2" version exercises a slightly different set of libarchive APIs. */
int read_open_memory2(struct archive *, void *, size_t, size_t);
/*
* ARCHIVE_VERSION_STAMP first appeared in 1.9 and libarchive 2.2.4.
* We can approximate it for earlier versions, though.
* This is used to disable tests of features not present in the current
* version.
*/
#ifndef ARCHIVE_VERSION_STAMP
#define ARCHIVE_VERSION_STAMP \
(ARCHIVE_API_VERSION * 1000000 + ARCHIVE_API_FEATURE * 1000)
/* Versions of above that accept an archive argument for additional info. */
#define assertA(e) test_assert(__FILE__, __LINE__, (e), #e, (a))
#define assertEqualIntA(a,v1,v2) \
test_assert_equal_int(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (a))
#define assertEqualStringA(a,v1,v2) \
test_assert_equal_string(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (a))
#endif
#endif
/*
* Special interfaces for libfreefare test harness.
*/
#include <nfc/nfc.h>
#include <freefare.h>
int mifare_classic_test_setup (MifareClassicTag *tag);
int mifare_classic_test_teardown (MifareClassicTag tag);
int read_data_block (char *filename, MifareClassicBlock *block);

80
test/test_access_bits.c
View file

@ -1,80 +0,0 @@
#include "test.h"
DEFINE_TEST(test_access_bit_read_data_block)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, 0x04, k, MFC_KEY_A);
assertEqualInt (res, 0);
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_R, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_R, MFC_KEY_B) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_W, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_W, MFC_KEY_B) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_D, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_D, MFC_KEY_B) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_I, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_I, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_KEYA, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_KEYA, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_KEYA, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_KEYA, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_ACCESS_BITS, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_ACCESS_BITS, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_ACCESS_BITS, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_ACCESS_BITS, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_KEYB, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_KEYB, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_KEYB, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_KEYB, MFC_KEY_B) );
} while (0);
mifare_classic_test_teardown (tag);
}
DEFINE_TEST(test_access_bit_read_trailer_block)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, 0x07, k, MFC_KEY_A);
assertEqualInt (res, 0);
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_R, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_R, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_W, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_W, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_D, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_D, MFC_KEY_B) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_I, MFC_KEY_A) );
assertEqualInt (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_I, MFC_KEY_B) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_KEYA, MFC_KEY_A) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_KEYA, MFC_KEY_B) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_KEYA, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_KEYA, MFC_KEY_B) );
assertEqualInt (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_ACCESS_BITS, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_ACCESS_BITS, MFC_KEY_B) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_ACCESS_BITS, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_ACCESS_BITS, MFC_KEY_B) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_KEYB, MFC_KEY_A) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_KEYB, MFC_KEY_B) );
assertEqualInt (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_KEYB, MFC_KEY_A) );
assertEqualInt (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_KEYB, MFC_KEY_B) );
} while (0);
mifare_classic_test_teardown (tag);
}

27
test/test_authenticate.c
View file

@ -1,27 +0,0 @@
#include "test.h"
#include <err.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <nfc/nfc.h>
DEFINE_TEST(test_authenticate)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicKey k = { 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5 };
res = mifare_classic_authenticate (tag, 0x00, k, MFC_KEY_A);
assertEqualInt (res, 0);
} while (0);
mifare_classic_test_teardown (tag);
}

17
test/test_create_trailer_block.c
View file

@ -1,17 +0,0 @@
#include "test.h"
DEFINE_TEST(test_create_trailer_block)
{
do {
MifareClassicBlock data;
MifareClassicKey key_a = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
MifareClassicKey key_b = { 0xde, 0xad, 0xbe, 0xef, 0xff, 0xff };
mifare_classic_trailer_block (&data, key_a, 0, 0, 0, 4, 0x42, key_b);
assertEqualMem (data, "\xff\xff\xff\xff\xff\xff\xff\x07\x80\x42\xde\xad\xbe\xef\xff\xff", sizeof (data));
} while (0);
}

61
test/test_format.c
View file

@ -1,61 +0,0 @@
#include "test.h"
#include <err.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <nfc/nfc.h>
DEFINE_TEST(test_format)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicKey k = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
res = mifare_classic_authenticate (tag, 0x3c, k, MFC_KEY_A);
assertEqualInt (res, 0);
MifareClassicBlock data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
};
MifareClassicBlock empty;
memset (empty, '\x00', sizeof (empty));
res = mifare_classic_write (tag, 0x3c, data);
assertEqualInt (res, 0);
res = mifare_classic_write (tag, 0x3d, data);
assertEqualInt (res, 0);
res = mifare_classic_write (tag, 0x3e, data);
assertEqualInt (res, 0);
res = mifare_classic_format_sector (tag, 0x0f);
assertEqualInt (res, 0);
res = mifare_classic_read (tag, 0x3c, &data);
assertEqualInt (res, 0);
assertEqualMem (data, empty, sizeof (data));
res = mifare_classic_read (tag, 0x3d, &data);
assertEqualInt (res, 0);
assertEqualMem (data, empty, sizeof (data));
res = mifare_classic_read (tag, 0x3e, &data);
assertEqualInt (res, 0);
assertEqualMem (data, empty, sizeof (data));
res = mifare_classic_read (tag, 0x3f, &data);
assertEqualInt (res, 0);
assertEqualMem (data, "\x00\x00\x00\x00\x00\x00\xff\x07\x80\x69\xff\xff\xff\xff\xff\xff", sizeof (data));
} while (0);
mifare_classic_test_teardown (tag);
}

469
test/test_mad.c
View file

@ -1,324 +1,289 @@
#include "test.h"
#include <cutter.h>
#include <freefare.h>
#include "freefare_internal.h"
DEFINE_TEST(test_mad)
void
test_mad (void)
{
int res;
do {
Mad mad = mad_new (1);
assert (mad != NULL);
Mad mad = mad_new (1);
cut_assert_not_null (mad);
if (mad) {
assertEqualInt (mad_get_version (mad), 1);
mad_set_version (mad, 2);
assertEqualInt (mad_get_version (mad), 2);
cut_assert_equal_int (1, mad_get_version (mad));
mad_set_version (mad, 2);
cut_assert_equal_int (2, mad_get_version (mad));
assertEqualInt (0, mad_get_card_publisher_sector (mad));
cut_assert_equal_int (0, mad_get_card_publisher_sector (mad));
res = mad_set_card_publisher_sector (mad, 13);
assertEqualInt (res, 0);
assertEqualInt (13, mad_get_card_publisher_sector (mad));
res = mad_set_card_publisher_sector (mad, 13);
cut_assert_equal_int (res, 0);
cut_assert_equal_int (13, mad_get_card_publisher_sector (mad));
res = mad_set_card_publisher_sector (mad, 0xff);
assertEqualInt (res, -1);
assertEqualInt (13, mad_get_card_publisher_sector (mad));
res = mad_set_card_publisher_sector (mad, 0xff);
cut_assert_equal_int (res, -1);
cut_assert_equal_int (13, mad_get_card_publisher_sector (mad));
MadAid aid = {
.function_cluster_code = 0,
.application_code = 0
};
MadAid aid = {
.function_cluster_code = 0,
.application_code = 0
};
res = mad_get_aid (mad, 3, &aid);
assertEqualInt (res, 0);
assertEqualInt (aid.function_cluster_code, 0);
assertEqualInt (aid.application_code, 0);
res = mad_get_aid (mad, 3, &aid);
cut_assert_equal_int (0, res);
cut_assert_equal_int (0, aid.function_cluster_code);
cut_assert_equal_int (0, aid.application_code);
aid.function_cluster_code = 0xc0;
aid.application_code = 0x42;
res = mad_set_aid (mad, 3, aid);
assertEqualInt (res, 0);
aid.function_cluster_code = 0xc0;
aid.application_code = 0x42;
res = mad_set_aid (mad, 3, aid);
cut_assert_equal_int (0, res);
res = mad_get_aid (mad, 3, &aid);
assertEqualInt (res, 0);
assertEqualInt (aid.function_cluster_code, 0xc0);
assertEqualInt (aid.application_code, 0x42);
res = mad_get_aid (mad, 3, &aid);
cut_assert_equal_int (0, res);
cut_assert_equal_int (0xC0, aid.function_cluster_code);
cut_assert_equal_int (0x42, aid.application_code);
mad_free (mad);
}
} while (0);
mad_free (mad);
}
#define CRC_PRESET 0x67
DEFINE_TEST(test_mad_crc8_basic)
void
test_mad_crc8_basic (void)
{
do {
uint8_t crc;
const uint8_t crc_value = 0x42;
uint8_t crc;
const uint8_t crc_value = 0x42;
/* Insert data */
crc = 0x00;
crc8(&crc, crc_value);
assertEqualInt (crc, crc_value);
/* Insert data */
crc = 0x00;
crc8(&crc, crc_value);
cut_assert_equal_int (crc_value, crc);
/* Insert data with leading zeros */
crc = 0x00;
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, crc_value);
assertEqualInt (crc, crc_value);
/* Insert data with leading zeros */
crc = 0x00;
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, crc_value);
cut_assert_equal_int (crc_value, crc);
/* Check integrity */
crc = CRC_PRESET;
crc8(&crc, crc_value);
crc8(&crc, 0x00);
uint8_t save = crc;
/* Check integrity */
crc = CRC_PRESET;
crc8(&crc, crc_value);
crc8(&crc, 0x00);
uint8_t save = crc;
crc = CRC_PRESET;
crc8(&crc, crc_value);
crc8(&crc, save);
assertEqualInt (crc, 0x00);
} while (0);
crc = CRC_PRESET;
crc8(&crc, crc_value);
crc8(&crc, save);
cut_assert_equal_int (0x00, crc);
}
/*
* The following MAD values where extracted from documentation.
*/
DEFINE_TEST(test_mad_crc8_doc_example)
void
test_mad_crc8_doc_example (void)
{
do {
/* Preset */
uint8_t crc = CRC_PRESET;
/* Preset */
uint8_t crc = CRC_PRESET;
/* Block 1 -- 0x01 - 0x07 */
crc8(&crc, 0x01);
crc8(&crc, 0x01);
crc8(&crc, 0x08);
crc8(&crc, 0x01);
crc8(&crc, 0x08);
crc8(&crc, 0x01);
crc8(&crc, 0x08);
/* Block 1 -- 0x01 - 0x07 */
crc8(&crc, 0x01);
crc8(&crc, 0x01);
crc8(&crc, 0x08);
crc8(&crc, 0x01);
crc8(&crc, 0x08);
crc8(&crc, 0x01);
crc8(&crc, 0x08);
/* Block 2 -- 0x08 - 0x0f */
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x04);
crc8(&crc, 0x00);
/* Block 2 -- 0x08 - 0x0f */
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x04);
crc8(&crc, 0x00);
/* Block 3 -- 0x00 - 0x07 */
crc8(&crc, 0x03);
crc8(&crc, 0x10);
crc8(&crc, 0x03);
crc8(&crc, 0x10);
crc8(&crc, 0x02);
crc8(&crc, 0x10);
crc8(&crc, 0x02);
crc8(&crc, 0x10);
/* Block 3 -- 0x00 - 0x07 */
crc8(&crc, 0x03);
crc8(&crc, 0x10);
crc8(&crc, 0x03);
crc8(&crc, 0x10);
crc8(&crc, 0x02);
crc8(&crc, 0x10);
crc8(&crc, 0x02);
crc8(&crc, 0x10);
/* Block 3 -- 0x08 - 0x0f */
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x11);
crc8(&crc, 0x30);
/* Block 3 -- 0x08 - 0x0f */
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x11);
crc8(&crc, 0x30);
/* Append zeros of augmented message */
crc8(&crc, 0x00);
/* Append zeros of augmented message */
crc8(&crc, 0x00);
assertEqualInt (crc, 0x89);
} while (0);
cut_assert_equal_int (0x89, crc);
}
/*
* The following MAD values where extracted from a MIFARE dump.
*/
DEFINE_TEST(test_mad_crc8_real_example_1)
void
test_mad_crc8_real_example_1 (void)
{
do {
/* Preset */
uint8_t crc = CRC_PRESET;
/* Preset */
uint8_t crc = CRC_PRESET;
/* Block 1 -- 0x01 - 0x07 */
crc8(&crc, 0x01);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
/* Block 1 -- 0x01 - 0x07 */
crc8(&crc, 0x01);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
/* Block 2 -- 0x08 - 0x0f */
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
/* Block 2 -- 0x08 - 0x0f */
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
/* Block 3 -- 0x00 - 0x07 */
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
/* Block 3 -- 0x00 - 0x07 */
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
/* Block 3 -- 0x08 - 0x0f */
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
/* Block 3 -- 0x08 - 0x0f */
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
/* Append zeros of augmented message */
crc8(&crc, 0x00);
/* Append zeros of augmented message */
crc8(&crc, 0x00);
assertEqualInt (crc, 0xc4);
} while (0);
cut_assert_equal_int (0xc4, crc);
}
/*
* The following MAD values where extracted from a MIFARE dump.
*/
DEFINE_TEST(test_mad_crc8_real_example_2)
void
test_mad_crc8_real_example_2 (void)
{
do {
/* Preset */
uint8_t crc = CRC_PRESET;
/* Preset */
uint8_t crc = CRC_PRESET;
/* Block 1 -- 0x01 - 0x07 */
crc8(&crc, 0x01);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
/* Block 1 -- 0x01 - 0x07 */
crc8(&crc, 0x01);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
/* Block 2 -- 0x08 - 0x0f */
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
/* Block 2 -- 0x08 - 0x0f */
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x03);
crc8(&crc, 0xe1);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
/* Block 3 -- 0x00 - 0x07 */
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
/* Block 3 -- 0x00 - 0x07 */
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
/* Block 3 -- 0x08 - 0x0f */
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
/* Block 3 -- 0x08 - 0x0f */
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
crc8(&crc, 0x00);
/* Append zeros of augmented message */
crc8(&crc, 0x00);
/* Append zeros of augmented message */
crc8(&crc, 0x00);
assertEqualInt (crc, 0xab);
} while (0);
cut_assert_equal_int (0xab, crc);
}
DEFINE_TEST (test_mad_sector_0x00_crc8)
void
test_mad_sector_0x00_crc8 (void)
{
int res;
Mad mad = mad_new (1);
cut_assert_not_null (mad);
do {
Mad mad = mad_new (1);
assert (mad != NULL);
res = mad_set_card_publisher_sector (mad, 0x01);
if (mad) {
res = mad_set_card_publisher_sector (mad, 0x01);
/* Block 1 */
MadAid aid1 = { 0x01, 0x08 };
mad_set_aid (mad, 1, aid1);
mad_set_aid (mad, 2, aid1);
mad_set_aid (mad, 3, aid1);
/* Block 1 */
MadAid aid1 = { 0x01, 0x08 };
mad_set_aid (mad, 1, aid1);
mad_set_aid (mad, 2, aid1);
mad_set_aid (mad, 3, aid1);
/* Block 2 */
MadAid empty_aid = { 0x00, 0x00 };
mad_set_aid (mad, 4, empty_aid);
mad_set_aid (mad, 5, empty_aid);
mad_set_aid (mad, 6, empty_aid);
MadAid aid2 = { 0x04, 0x00 };
mad_set_aid (mad, 7, aid2);
/* Block 2 */
MadAid empty_aid = { 0x00, 0x00 };
mad_set_aid (mad, 4, empty_aid);
mad_set_aid (mad, 5, empty_aid);
mad_set_aid (mad, 6, empty_aid);
MadAid aid2 = { 0x04, 0x00 };
mad_set_aid (mad, 7, aid2);
/* Block 3 */
MadAid aid3 = { 0x03, 0x10 };
mad_set_aid (mad, 8, aid3);
mad_set_aid (mad, 9, aid3);
MadAid aid4 = { 0x02, 0x10 };
mad_set_aid (mad, 10, aid4);
mad_set_aid (mad, 11, aid4);
/* Block 3 */
MadAid aid3 = { 0x03, 0x10 };
mad_set_aid (mad, 8, aid3);
mad_set_aid (mad, 9, aid3);
MadAid aid4 = { 0x02, 0x10 };
mad_set_aid (mad, 10, aid4);
mad_set_aid (mad, 11, aid4);
mad_set_aid (mad, 12, empty_aid);
mad_set_aid (mad, 13, empty_aid);
mad_set_aid (mad, 14, empty_aid);
MadAid aid5 = { 0x11, 0x30 };
mad_set_aid (mad, 15, aid5);
mad_set_aid (mad, 12, empty_aid);
mad_set_aid (mad, 13, empty_aid);
mad_set_aid (mad, 14, empty_aid);
MadAid aid5 = { 0x11, 0x30 };
mad_set_aid (mad, 15, aid5);
res = sector_0x00_crc8 (mad);
cut_assert_equal_int(0x89, res);
res = sector_0x00_crc8 (mad);
assertEqualInt(0x89, res);
}
mad_free (mad);
} while (0);
}
DEFINE_TEST (test_mad_read)
{
int res;
MifareClassicTag tag;
do
{
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
Mad mad = mad_read (tag);
if (!mad) {
assertEqualInt (0, 1);
}
} while (0);
mifare_classic_test_teardown (tag);
mad_free (mad);
}

37
test/test_mifare_application.c
View file

@ -1,37 +0,0 @@
#include "test.h"
DEFINE_TEST(test_mifare_application)
{
do {
/* Card publisher part */
MadAid aid = { 0x22, 0x42 };
Mad mad = mad_new (2);
assert (NULL != mad);
MifareSectorNumber *s_alloc = mifare_application_alloc (mad, aid, 3);
assert (NULL != s_alloc);
MifareSectorNumber *s_found = mifare_application_find (mad, aid);
assert (NULL != s_found);
for (int i = 0; i < 3; i++) {
assertEqualInt (s_alloc[i], s_found[i]);
}
assertEqualInt (0, s_alloc[3]);
assertEqualInt (0, s_found[3]);
mifare_application_free (mad, aid);
free (s_alloc);
free (s_found);
s_found = mifare_application_find (mad, aid);
assert (s_found == NULL);
mad_free (mad);
} while (0);
}

307
test/test_mifare_classic.c Normal file
View file

@ -0,0 +1,307 @@
#include <cutter.h>
#include <string.h>
#include <freefare.h>
#include "mifare_classic_fixture.h"
void
test_mifare_classic_authenticate (void)
{
int res;
MifareClassicKey k = { 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5 };
res = mifare_classic_authenticate (tag, 0x00, k, MFC_KEY_A);
cut_assert_equal_int (0, res);
}
void
test_mifare_classic_read_sector_0 (void)
{
int res;
cut_omit ("Requires a particular NFC tag");
MifareClassicKey k = { 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5 };
res = mifare_classic_authenticate (tag, 0x00, k, MFC_KEY_A);
cut_assert_equal_int (0, res);
MifareClassicBlock r;
res = mifare_classic_read (tag, 0x00, &r);
cut_assert_equal_int (0, res);
MifareClassicBlock e = { 0xba, 0xc7, 0x7a, 0xfc, 0xfb, 0x88, 0x04, 0x00 , 0x46, 0x5d, 0x55, 0x96, 0x41, 0x10, 0x19, 0x08 };
cut_assert_equal_memory (e, sizeof (e), r, sizeof (r));
}
void
test_mifare_classic_get_data_block_permission (void)
{
int res;
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, 0x04, k, MFC_KEY_A);
cut_assert_equal_int (0, res);
cut_assert_equal_int (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_R, MFC_KEY_A) );
cut_assert_equal_int (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_R, MFC_KEY_B) );
cut_assert_equal_int (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_W, MFC_KEY_A) );
cut_assert_equal_int (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_W, MFC_KEY_B) );
cut_assert_equal_int (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_D, MFC_KEY_A) );
cut_assert_equal_int (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_D, MFC_KEY_B) );
cut_assert_equal_int (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_I, MFC_KEY_A) );
cut_assert_equal_int (1, mifare_classic_get_data_block_permission(tag, 0x04, MCAB_I, MFC_KEY_B) );
cut_assert_equal_int (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_KEYA, MFC_KEY_A) );
cut_assert_equal_int (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_KEYA, MFC_KEY_B) );
cut_assert_equal_int (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_KEYA, MFC_KEY_A) );
cut_assert_equal_int (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_KEYA, MFC_KEY_B) );
cut_assert_equal_int (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_ACCESS_BITS, MFC_KEY_A) );
cut_assert_equal_int (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_ACCESS_BITS, MFC_KEY_B) );
cut_assert_equal_int (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_ACCESS_BITS, MFC_KEY_A) );
cut_assert_equal_int (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_ACCESS_BITS, MFC_KEY_B) );
cut_assert_equal_int (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_KEYB, MFC_KEY_A) );
cut_assert_equal_int (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_READ_KEYB, MFC_KEY_B) );
cut_assert_equal_int (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_KEYB, MFC_KEY_A) );
cut_assert_equal_int (-1, mifare_classic_get_trailer_block_permission(tag, 0x04, MCAB_WRITE_KEYB, MFC_KEY_B) );
}
void
test_mifare_classic_get_trailer_permission (void)
{
int res;
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, 0x07, k, MFC_KEY_A);
cut_assert_equal_int (res, 0);
cut_assert_equal_int (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_R, MFC_KEY_A) );
cut_assert_equal_int (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_R, MFC_KEY_B) );
cut_assert_equal_int (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_W, MFC_KEY_A) );
cut_assert_equal_int (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_W, MFC_KEY_B) );
cut_assert_equal_int (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_D, MFC_KEY_A) );
cut_assert_equal_int (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_D, MFC_KEY_B) );
cut_assert_equal_int (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_I, MFC_KEY_A) );
cut_assert_equal_int (-1, mifare_classic_get_data_block_permission(tag, 0x07, MCAB_I, MFC_KEY_B) );
cut_assert_equal_int (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_KEYA, MFC_KEY_A) );
cut_assert_equal_int (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_KEYA, MFC_KEY_B) );
cut_assert_equal_int (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_KEYA, MFC_KEY_A) );
cut_assert_equal_int (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_KEYA, MFC_KEY_B) );
cut_assert_equal_int (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_ACCESS_BITS, MFC_KEY_A) );
cut_assert_equal_int (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_ACCESS_BITS, MFC_KEY_B) );
cut_assert_equal_int (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_ACCESS_BITS, MFC_KEY_A) );
cut_assert_equal_int (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_ACCESS_BITS, MFC_KEY_B) );
cut_assert_equal_int (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_KEYB, MFC_KEY_A) );
cut_assert_equal_int (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_READ_KEYB, MFC_KEY_B) );
cut_assert_equal_int (0, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_KEYB, MFC_KEY_A) );
cut_assert_equal_int (1, mifare_classic_get_trailer_block_permission(tag, 0x07, MCAB_WRITE_KEYB, MFC_KEY_B) );
}
void
test_mifare_classic_read_mad (void)
{
Mad mad = mad_read (tag);
cut_assert_not_null (tag);
}
void
test_mifare_classic_format (void)
{
int res;
MifareClassicKey k = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
res = mifare_classic_authenticate (tag, 0x3c, k, MFC_KEY_A);
cut_assert_equal_int (0, res);
MifareClassicBlock data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
};
MifareClassicBlock empty;
memset (empty, '\x00', sizeof (empty));
res = mifare_classic_write (tag, 0x3c, data);
cut_assert_equal_int (0, res);
res = mifare_classic_write (tag, 0x3d, data);
cut_assert_equal_int (0, res);
res = mifare_classic_write (tag, 0x3e, data);
cut_assert_equal_int (0, res);
res = mifare_classic_format_sector (tag, 0x0f);
cut_assert_equal_int (0, res);
res = mifare_classic_read (tag, 0x3c, &data);
cut_assert_equal_int (0, res);
cut_assert_equal_memory (data, sizeof (data), empty, sizeof (data));
res = mifare_classic_read (tag, 0x3d, &data);
cut_assert_equal_int (0, res);
cut_assert_equal_memory (data, sizeof (data), empty, sizeof (data));
res = mifare_classic_read (tag, 0x3e, &data);
cut_assert_equal_int (0, res);
cut_assert_equal_memory (data, sizeof (data), empty, sizeof (data));
res = mifare_classic_read (tag, 0x3f, &data);
cut_assert_equal_int (0, res);
cut_assert_equal_memory (data, sizeof (data), "\x00\x00\x00\x00\x00\x00\xff\x07\x80\x69\xff\xff\xff\xff\xff\xff", sizeof (data));
}
void
test_mifare_classic_value_block_increment (void)
{
int res;
MifareClassicBlockNumber block = 0x04;
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, block, k, MFC_KEY_A);
cut_assert_equal_int (0, res);
res = mifare_classic_init_value (tag, block, 1000, 0x00);
cut_assert_equal_int (0, res);
/* Initialize value block */
int32_t value;
MifareClassicBlockNumber adr;
res = mifare_classic_read_value (tag, block, &value, &adr);
cut_assert_equal_int (0, res, 0);
cut_assert_equal_int (1000, value);
cut_assert_equal_int (0x00, adr);
/* Increment by 1 */
res = mifare_classic_increment (tag, block, 1);
cut_assert_equal_int (0, res);
res = mifare_classic_transfer (tag, block);
cut_assert_equal_int (0, res);
res = mifare_classic_read_value (tag, block, &value, &adr);
cut_assert_equal_int (0, res);
cut_assert_equal_int (1001, value);
cut_assert_equal_int (0x00, adr);
/* Increment by 10 */
res = mifare_classic_increment (tag, block, 10);
cut_assert_equal_int (0, res);
res = mifare_classic_transfer (tag, block);
cut_assert_equal_int (0, res);
res = mifare_classic_read_value (tag, block, &value, &adr);
cut_assert_equal_int (0, res);
cut_assert_equal_int (1011, value);
cut_assert_equal_int (0x00, adr);
}
void
test_mifare_classic_value_block_decrement (void)
{
int res;
MifareClassicBlockNumber block = 0x04;
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, block, k, MFC_KEY_A);
cut_assert_equal_int (0, res);
res = mifare_classic_init_value (tag, block, 1000, 0x00);
cut_assert_equal_int (0, res);
/* Initialize value block */
int32_t value;
MifareClassicBlockNumber adr;
res = mifare_classic_read_value (tag, block, &value, &adr);
cut_assert_equal_int (0, res);
cut_assert_equal_int (1000, value);
cut_assert_equal_int (0x00, adr);
/* Decrement */
res = mifare_classic_decrement (tag, block, 1);
cut_assert_equal_int (0, res);
res = mifare_classic_transfer (tag, block);
cut_assert_equal_int (0, res);
res = mifare_classic_read_value (tag, block, &value, &adr);
cut_assert_equal_int (0, res);
cut_assert_equal_int (999, value);
cut_assert_equal_int (0x00, adr);
res = mifare_classic_decrement (tag, block, 1000);
cut_assert_equal_int (0, res);
res = mifare_classic_transfer (tag, block);
cut_assert_equal_int (0, res);
res = mifare_classic_read_value (tag, block, &value, &adr);
cut_assert_equal_int (0, res);
cut_assert_equal_int (-1, value);
cut_assert_equal_int (0x00, adr);
}
void
test_mifare_classic_value_block_restore (void)
{
int res;
MifareClassicBlockNumber block = 0x04;
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, block, k, MFC_KEY_A);
cut_assert_equal_int (0, res);
/* Restore */
MifareClassicBlock data;
MifareClassicBlock sample = {
0xe8, 0x03, 0x00, 0x00,
0x17, 0xfc, 0xff, 0xff,
0xe8, 0x03, 0x00, 0x00,
0x00,
0xff,
0x00,
0xff
};
MifareClassicBlock nul = {
0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00,
0x00,
0xff,
0x00,
0xff
};
res = mifare_classic_write (tag, block, sample);
cut_assert_equal_int (0, res);
res = mifare_classic_read (tag, block, &data);
cut_assert_equal_int (0, res);
cut_assert_equal_memory (sample, sizeof (sample), data, sizeof (data));
res = mifare_classic_write (tag, block+1, nul);
cut_assert_equal_int (0, res);
res = mifare_classic_read (tag, block+1, &data);
cut_assert_equal_int (0, res);
cut_assert_equal_memory (nul, sizeof (sample), data, sizeof (data));
res = mifare_classic_restore (tag, block);
cut_assert_equal_int (0, res);
res = mifare_classic_transfer (tag, block+1);
cut_assert_equal_int (0, res);
res = mifare_classic_read (tag, block+1, &data);
cut_assert_equal_int (0, res);
cut_assert_equal_memory (sample, sizeof (sample), data, sizeof (data));
}

36
test/test_mifare_classic_application.c Normal file
View file

@ -0,0 +1,36 @@
#include <cutter.h>
#include <freefare.h>
void
test_mifare_classic_application (void)
{
/* Card publisher part */
MadAid aid = { 0x22, 0x42 };
Mad mad = mad_new (2);
cut_assert_not_null (mad);
MifareSectorNumber *s_alloc = mifare_application_alloc (mad, aid, 3);
cut_assert_not_null (s_alloc);
MifareSectorNumber *s_found = mifare_application_find (mad, aid);
cut_assert_not_null (s_found);
for (int i = 0; i < 3; i++) {
cut_assert_equal_int (s_alloc[i], s_found[i]);
}
cut_assert_equal_int (0, s_alloc[3]);
cut_assert_equal_int (0, s_found[3]);
mifare_application_free (mad, aid);
free (s_alloc);
free (s_found);
s_found = mifare_application_find (mad, aid);
cut_assert_null (s_found);
mad_free (mad);
}

17
test/test_mifare_classic_create_trailer_block.c Normal file
View file

@ -0,0 +1,17 @@
#include <cutter.h>
#include <freefare.h>
void
test_mifare_classic_create_trailer_block (void)
{
MifareClassicBlock data;
MifareClassicKey key_a = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
MifareClassicKey key_b = { 0xde, 0xad, 0xbe, 0xef, 0xff, 0xff };
mifare_classic_trailer_block (&data, key_a, 0, 0, 0, 4, 0x42, key_b);
cut_assert_equal_memory (data, sizeof (data), "\xff\xff\xff\xff\xff\xff\xff\x07\x80\x42\xde\xad\xbe\xef\xff\xff", sizeof (data));
}

44
test/test_read_sector_0.c
View file

@ -1,44 +0,0 @@
#include "test.h"
#include <err.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <nfc/nfc.h>
DEFINE_TEST(test_read_sector_0)
{
MifareClassicTag tag;
int res ;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicKey k = { 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5 };
res = mifare_classic_authenticate (tag, 0x00, k, MFC_KEY_A);
assertEqualInt (res, 0);
MifareClassicBlock r;
res = mifare_classic_read (tag, 0x00, &r);
assertEqualInt (res, 0);
extract_reference_file ("test_read_sector_0");
FILE *f = fopen("test_read_sector_0", "r");
char buffer[17];
fgets (buffer, 17, f);
assertEqualMem (r, buffer, 16);
fclose (f);
} while (0);
mifare_classic_test_teardown (tag);
}

4
test/test_read_sector_0.uu
View file

@ -1,4 +0,0 @@
begin 644 test_read_sector_0
0NL=Z_/N(!`!&756601`9"```
`
end

163
test/test_value_block.c
View file

@ -1,163 +0,0 @@
#include "test.h"
DEFINE_TEST(test_value_block_increment)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicBlockNumber block = 0x04;
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, block, k, MFC_KEY_A);
assertEqualInt (res, 0);
res = mifare_classic_init_value (tag, block, 1000, 0x00);
assertEqualInt (res, 0);
/* Initialize value block */
int32_t value;
MifareClassicBlockNumber adr;
res = mifare_classic_read_value (tag, block, &value, &adr);
assertEqualInt (res, 0);
assertEqualInt (value, 1000);
assertEqualInt (adr, 0x00);
/* Increment by 1 */
res = mifare_classic_increment (tag, block, 1);
assertEqualInt (res, 0);
res = mifare_classic_transfer (tag, block);
assertEqualInt (res, 0);
res = mifare_classic_read_value (tag, block, &value, &adr);
assertEqualInt (res, 0);
assertEqualInt (value, 1001);
assertEqualInt (adr, 0x00);
/* Increment by 10 */
res = mifare_classic_increment (tag, block, 10);
assertEqualInt (res, 0);
res = mifare_classic_transfer (tag, block);
assertEqualInt (res, 0);
res = mifare_classic_read_value (tag, block, &value, &adr);
assertEqualInt (res, 0);
assertEqualInt (value, 1011);
assertEqualInt (adr, 0x00);
} while (0);
mifare_classic_test_teardown (tag);
}
DEFINE_TEST(test_value_block_decrement)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicBlockNumber block = 0x04;
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, block, k, MFC_KEY_A);
assertEqualInt (res, 0);
res = mifare_classic_init_value (tag, block, 1000, 0x00);
assertEqualInt (res, 0);
/* Initialize value block */
int32_t value;
MifareClassicBlockNumber adr;
res = mifare_classic_read_value (tag, block, &value, &adr);
assertEqualInt (res, 0);
assertEqualInt (value, 1000);
assertEqualInt (adr, 0x00);
/* Decrement */
res = mifare_classic_decrement (tag, block, 1);
assertEqualInt (res, 0);
res = mifare_classic_transfer (tag, block);
assertEqualInt (res, 0);
res = mifare_classic_read_value (tag, block, &value, &adr);
assertEqualInt (res, 0);
assertEqualInt (value, 999);
assertEqualInt (adr, 0x00);
res = mifare_classic_decrement (tag, block, 1000);
assertEqualInt (res, 0);
res = mifare_classic_transfer (tag, block);
assertEqualInt (res, 0);
res = mifare_classic_read_value (tag, block, &value, &adr);
assertEqualInt (res, 0);
assertEqualInt (value, -1);
assertEqualInt (adr, 0x00);
} while (0);
mifare_classic_test_teardown (tag);
}
DEFINE_TEST(test_value_block_restore)
{
int res;
MifareClassicTag tag;
do {
res = mifare_classic_test_setup (&tag);
assertEqualInt (res, 0);
MifareClassicBlockNumber block = 0x04;
MifareClassicKey k = { 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7 };
res = mifare_classic_authenticate (tag, block, k, MFC_KEY_A);
assertEqualInt (res, 0);
/* Restore */
extract_reference_file ("sample_value_block");
extract_reference_file ("null_value_block");
MifareClassicBlock data, sample, nul;
read_data_block ("sample_value_block", &sample);
read_data_block ("null_value_block", &nul);
res = mifare_classic_write (tag, block, sample);
assertEqualInt (res, 0);
res = mifare_classic_read (tag, block, &data);
assertEqualInt (res, 0);
assertEqualMem (sample, data, sizeof (data));
res = mifare_classic_write (tag, block+1, nul);
assertEqualInt (res, 0);
res = mifare_classic_read (tag, block+1, &data);
assertEqualInt (res, 0);
assertEqualMem (nul, data, sizeof (data));
res = mifare_classic_restore (tag, block);
assertEqualInt (res, 0);
res = mifare_classic_transfer (tag, block+1);
assertEqualInt (res, 0);
res = mifare_classic_read (tag, block+1, &data);
assertEqualInt (res, 0);
assertEqualMem (sample, data, sizeof (data));
} while (0);
mifare_classic_test_teardown (tag);
}