]> cvs.zerfleddert.de Git - proxmark3-svn/commitdiff
Add flasher from SVN r623 for HID bootprom and current Mac OS X kext 55/head
authorJesse Hallio <github@jesse.iki.fi>
Tue, 3 Feb 2015 21:22:39 +0000 (23:22 +0200)
committerJesse Hallio <github@jesse.iki.fi>
Tue, 3 Feb 2015 21:22:39 +0000 (23:22 +0200)
15 files changed:
client/Info.plist [deleted file]
client/Makefile
client/hid-flasher/Info.plist [new file with mode: 0644]
client/hid-flasher/Makefile [new file with mode: 0644]
client/hid-flasher/elf.h [new file with mode: 0644]
client/hid-flasher/flash.c [new file with mode: 0644]
client/hid-flasher/flash.h [new file with mode: 0644]
client/hid-flasher/flasher.c [new file with mode: 0644]
client/hid-flasher/obj/.dummy [new file with mode: 0644]
client/hid-flasher/proxendian.h [new file with mode: 0644]
client/hid-flasher/proxmark3.h [new file with mode: 0644]
client/hid-flasher/proxusb.c [new file with mode: 0644]
client/hid-flasher/proxusb.h [new file with mode: 0644]
client/hid-flasher/sleep.h [new file with mode: 0644]
client/hid-flasher/usb_cmd.h [new file with mode: 0644]

diff --git a/client/Info.plist b/client/Info.plist
deleted file mode 100644 (file)
index d1f8757..0000000
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd ">
-<plist version="1.0">
-<dict>
-       <key>CFBundleDevelopmentRegion</key> <string>English</string>
-       <key>CFBundleIdentifier</key> <string>org.proxmark</string>
-       <key>CFBundleIconFile</key> <string></string>
-       <key>CFBundleInfoDictionaryVersion</key> <string>6.0</string>
-       <key>CFBundlePackageType</key> <string>KEXT</string>
-       <key>CFBundleSignature</key> <string>????</string>
-       <key>CFBundleVersion</key> <string>1.0.0</string>
-       <key>IOKitPersonalities</key>
-       <dict>
-               <key>Proxmark3</key>
-               <dict>
-                       <key>CFBundleIdentifier</key><string>com.apple.kernel.iokit</string>
-                       <key>IOClass</key><string>IOService</string>
-                       <key>IOProviderClass</key><string>IOUSBInterface</string>
-                       <key>bConfigurationValue</key> <integer>1</integer>
-                       <key>bInterfaceNumber</key> <integer>0</integer>
-                       <key>idProduct</key><integer>19343</integer>
-                       <key>idVendor</key><integer>39620</integer>
-               </dict>
-       </dict>
-       <key>OSBundleLibraries</key>
-       <dict>
-               <key>com.apple.iokit.IOUSBFamily</key><string>1.8</string>
-       </dict>
-</dict>
-</plist>
index 823ee44599e24beecfdc2323850a779529ff0926..e63581ba1ff864520167f5406c96b7dcf53dbe23 100644 (file)
@@ -137,17 +137,6 @@ clean:
 tarbin: $(BINS)
        $(TAR) $(TARFLAGS) ../proxmark3-$(platform)-bin.tar $(BINS:%=client/%)
 
-# must be run as root
-install_kext: Info.plist
-       mkdir -p /System/Library/Extensions/Proxmark3.kext/Contents
-       cp Info.plist /System/Library/Extensions/Proxmark3.kext/Contents
-       chown -R root:wheel /System/Library/Extensions/Proxmark3.kext
-       chmod 755 /System/Library/Extensions/Proxmark3.kext /System/Library/Extensions/Proxmark3.kext/Contents
-       chmod 644 /System/Library/Extensions/Proxmark3.kext/Contents/Info.plist
-       rm -rf /System/Library/Caches/com.apple.kext.caches
-       touch /System/Library/Extensions
-       @echo "*** You may need to reboot for the kext to take effect."
-
 lua_build:
        @echo Compiling liblua, using platform $(LUAPLATFORM)
        cd ../liblua && make $(LUAPLATFORM)
diff --git a/client/hid-flasher/Info.plist b/client/hid-flasher/Info.plist
new file mode 100644 (file)
index 0000000..c78a68b
--- /dev/null
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<!-- This is a dummy driver which binds to Proxmark. It -->
+<!-- contains no actual code; its only purpose is to     -->
+<!-- prevent Apple's USBHID driver from exclusively      -->
+<!-- opening the device.                                 -->
+<plist version="1.0">
+<dict>
+       <key>CFBundleDevelopmentRegion</key>
+       <string>English</string>
+       <key>CFBundleIconFile</key>
+       <string></string>
+       <key>CFBundleIdentifier</key>
+       <string>com.proxmark.driver.dummy</string>
+       <key>CFBundleInfoDictionaryVersion</key>
+       <string>6.0</string>
+       <key>CFBundlePackageType</key>
+       <string>KEXT</string>
+       <key>CFBundleSignature</key>
+       <string>????</string>
+       <key>CFBundleVersion</key>
+       <string>1.0.0d2</string>
+       <key>IOKitPersonalities</key>
+       <dict>
+               <!-- The Proxmark3 USB interface -->
+               <key>Proxmark3</key>
+               <dict>
+                       <key>CFBundleIdentifier</key>
+                       <string>com.apple.kpi.iokit</string>
+                       <key>IOClass</key>
+                       <string>IOService</string>
+                       <key>IOProviderClass</key>
+                       <string>IOUSBInterface</string>
+                       <key>bConfigurationValue</key>
+                       <integer>1</integer>
+                       <key>bInterfaceNumber</key>
+                       <integer>0</integer>
+                       <key>idProduct</key>
+                       <integer>19343</integer>
+                       <key>idVendor</key>
+                       <integer>39620</integer>
+               </dict>
+       </dict>
+       <key>OSBundleLibraries</key>
+       <dict>
+               <key>com.apple.iokit.IOUSBFamily</key>
+               <string>1.8</string>
+       </dict>
+</dict>
+</plist>
diff --git a/client/hid-flasher/Makefile b/client/hid-flasher/Makefile
new file mode 100644 (file)
index 0000000..5e9b6fc
--- /dev/null
@@ -0,0 +1,48 @@
+#-----------------------------------------------------------------------------
+# This code is licensed to you under the terms of the GNU GPL, version 2 or,
+# at your option, any later version. See the LICENSE.txt file for the text of
+# the license.
+#-----------------------------------------------------------------------------
+include ../../common/Makefile.common
+
+CC=gcc
+CXX=g++
+#COMMON_FLAGS = -m32
+
+VPATH = ../../common
+OBJDIR = obj
+
+LDLIBS = -L/opt/local/lib -L/usr/local/lib -lusb -lreadline -lpthread
+LDFLAGS = $(COMMON_FLAGS)
+CFLAGS = -std=gnu99 -I. -I../include -I../common -I/opt/local/include -Wall -Wno-unused-function $(COMMON_FLAGS) -g -O3
+
+CXXFLAGS =
+QTLDLIBS =
+
+RM = rm -f
+BINS = flasher
+CLEAN = flasher flasher.exe $(OBJDIR)/*.o *.o
+
+all: $(BINS)
+
+flasher: $(OBJDIR)/flash.o $(OBJDIR)/flasher.o $(OBJDIR)/proxusb.o
+       $(CXX) $(CXXFLAGS) $^ $(LDLIBS) -o $@
+
+$(OBJDIR)/%.o: %.c
+       $(CC) $(CFLAGS) -c -o $@ $<
+
+clean:
+       $(RM) $(CLEAN)
+
+# must be run as root
+install_kext: Info.plist
+       mkdir -p /System/Library/Extensions/Proxmark3.kext/Contents
+       cp Info.plist /System/Library/Extensions/Proxmark3.kext/Contents
+       chown -R root:wheel /System/Library/Extensions/Proxmark3.kext
+       chmod 755 /System/Library/Extensions/Proxmark3.kext /System/Library/Extensions/Proxmark3.kext/Contents
+       chmod 644 /System/Library/Extensions/Proxmark3.kext/Contents/Info.plist
+       rm -rf /System/Library/Caches/com.apple.kext.caches
+       touch /System/Library/Extensions
+       @echo "*** You may need to reboot for the kext to take effect."
+
+.PHONY: all clean
diff --git a/client/hid-flasher/elf.h b/client/hid-flasher/elf.h
new file mode 100644 (file)
index 0000000..90e2033
--- /dev/null
@@ -0,0 +1,71 @@
+//-----------------------------------------------------------------------------
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// ELF header
+//-----------------------------------------------------------------------------
+
+#ifndef __ELF_H__
+#define __ELF_H__
+
+typedef struct {
+       uint32_t p_type;
+       uint32_t p_offset;
+       uint32_t p_vaddr;
+       uint32_t p_paddr;
+       uint32_t p_filesz;
+       uint32_t p_memsz;
+       uint32_t p_flags;
+       uint32_t p_align;
+} __attribute__((__packed__)) Elf32_Phdr;
+
+#define EI_NIDENT 16
+
+typedef struct {
+       unsigned char   e_ident[EI_NIDENT];
+       uint16_t e_type;
+       uint16_t e_machine;
+       uint32_t e_version;
+       uint32_t e_entry;
+       uint32_t e_phoff;
+       uint32_t e_shoff;
+       uint32_t e_flags;
+       uint16_t e_ehsize;
+       uint16_t e_phentsize;
+       uint16_t e_phnum;
+       uint16_t e_shentsize;
+       uint16_t e_shnum;
+       uint16_t e_shtrndx;
+} __attribute__((__packed__)) Elf32_Ehdr;
+
+#define PT_NULL      0
+#define PT_LOAD      1
+#define PT_DYNAMIC   2
+#define PT_INTERP    3
+#define PT_NOTE      4
+#define PT_SHLIB     5
+#define PT_PHDR      6
+
+#define ELFCLASS32   1
+#define ELFCLASS64   2
+
+#define ELFDATA2LSB  1
+#define ELFDATA2MSB  2
+
+#define EV_CURRENT   1
+
+#define ET_NONE      0
+#define ET_REL       1
+#define ET_EXEC      2
+#define ET_DYN       3
+#define ET_CORE      4
+
+#define EM_ARM       0x28
+
+#define PF_R         4
+#define PF_W         2
+#define PF_X         1
+
+#endif
+
diff --git a/client/hid-flasher/flash.c b/client/hid-flasher/flash.c
new file mode 100644 (file)
index 0000000..6670d63
--- /dev/null
@@ -0,0 +1,478 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2010 Hector Martin "marcan" <marcan@marcansoft.com>
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// ELF file flasher
+//-----------------------------------------------------------------------------
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "sleep.h"
+#include "proxusb.h"
+#include "flash.h"
+#include "elf.h"
+#include "proxendian.h"
+
+// FIXME: what the fuckity fuck
+unsigned int current_command = CMD_UNKNOWN;
+
+#define FLASH_START            0x100000
+#define FLASH_SIZE             (256*1024)
+#define FLASH_END              (FLASH_START + FLASH_SIZE)
+#define BOOTLOADER_SIZE        0x2000
+#define BOOTLOADER_END         (FLASH_START + BOOTLOADER_SIZE)
+
+#define BLOCK_SIZE             0x100
+
+static const uint8_t elf_ident[] = {
+       0x7f, 'E', 'L', 'F',
+       ELFCLASS32,
+       ELFDATA2LSB,
+       EV_CURRENT
+};
+
+// Turn PHDRs into flasher segments, checking for PHDR sanity and merging adjacent
+// unaligned segments if needed
+static int build_segs_from_phdrs(flash_file_t *ctx, FILE *fd, Elf32_Phdr *phdrs, int num_phdrs)
+{
+       Elf32_Phdr *phdr = phdrs;
+       flash_seg_t *seg;
+       uint32_t last_end = 0;
+
+       ctx->segments = malloc(sizeof(flash_seg_t) * num_phdrs);
+       if (!ctx->segments) {
+               fprintf(stderr, "Out of memory\n");
+               return -1;
+       }
+       ctx->num_segs = 0;
+       seg = ctx->segments;
+
+       fprintf(stderr, "Loading usable ELF segments:\n");
+       for (int i = 0; i < num_phdrs; i++) {
+               if (le32(phdr->p_type) != PT_LOAD) {
+                       phdr++;
+                       continue;
+               }
+               uint32_t vaddr = le32(phdr->p_vaddr);
+               uint32_t paddr = le32(phdr->p_paddr);
+               uint32_t filesz = le32(phdr->p_filesz);
+               uint32_t memsz = le32(phdr->p_memsz);
+               uint32_t offset = le32(phdr->p_offset);
+               uint32_t flags = le32(phdr->p_flags);
+               if (!filesz) {
+                       phdr++;
+                       continue;
+               }
+               fprintf(stderr, "%d: V 0x%08x P 0x%08x (0x%08x->0x%08x) [%c%c%c] @0x%x\n",
+                       i, vaddr, paddr, filesz, memsz,
+                       flags & PF_R ? 'R' : ' ',
+                       flags & PF_W ? 'W' : ' ',
+                       flags & PF_X ? 'X' : ' ',
+                       offset);
+               if (filesz != memsz) {
+                       fprintf(stderr, "Error: PHDR file size does not equal memory size\n"
+                                       "(DATA+BSS PHDRs do not make sense on ROM platforms!)\n");
+                       return -1;
+               }
+               if (paddr < last_end) {
+                       fprintf(stderr, "Error: PHDRs not sorted or overlap\n");
+                       return -1;
+               }
+               if (paddr < FLASH_START || (paddr+filesz) > FLASH_END) {
+                       fprintf(stderr, "Error: PHDR is not contained in Flash\n");
+                       return -1;
+               }
+               if (vaddr >= FLASH_START && vaddr < FLASH_END && (flags & PF_W)) {
+                       fprintf(stderr, "Error: Flash VMA segment is writable\n");
+                       return -1;
+               }
+
+               uint8_t *data;
+               // make extra space if we need to move the data forward
+               data = malloc(filesz + BLOCK_SIZE);
+               if (!data) {
+                       fprintf(stderr, "Out of memory\n");
+                       return -1;
+               }
+               if (fseek(fd, offset, SEEK_SET) < 0 || fread(data, 1, filesz, fd) != filesz) {
+                       fprintf(stderr, "Error while reading PHDR payload\n");
+                       free(data);
+                       return -1;
+               }
+
+               uint32_t block_offset = paddr & (BLOCK_SIZE-1);
+               if (block_offset) {
+                       if (ctx->num_segs) {
+                               flash_seg_t *prev_seg = seg - 1;
+                               uint32_t this_end = paddr + filesz;
+                               uint32_t this_firstblock = paddr & ~(BLOCK_SIZE-1);
+                               uint32_t prev_lastblock = (last_end - 1) & ~(BLOCK_SIZE-1);
+
+                               if (this_firstblock == prev_lastblock) {
+                                       uint32_t new_length = this_end - prev_seg->start;
+                                       uint32_t this_offset = paddr - prev_seg->start;
+                                       uint32_t hole = this_offset - prev_seg->length;
+                                       uint8_t *new_data = malloc(new_length);
+                                       if (!new_data) {
+                                               fprintf(stderr, "Out of memory\n");
+                                               free(data);
+                                               return -1;
+                                       }
+                                       memset(new_data, 0xff, new_length);
+                                       memcpy(new_data, prev_seg->data, prev_seg->length);
+                                       memcpy(new_data + this_offset, data, filesz);
+                                       fprintf(stderr, "Note: Extending previous segment from 0x%x to 0x%x bytes\n",
+                                               prev_seg->length, new_length);
+                                       if (hole)
+                                               fprintf(stderr, "Note: 0x%x-byte hole created\n", hole);
+                                       free(data);
+                                       free(prev_seg->data);
+                                       prev_seg->data = new_data;
+                                       prev_seg->length = new_length;
+                                       last_end = this_end;
+                                       phdr++;
+                                       continue;
+                               }
+                       }
+                       fprintf(stderr, "Warning: segment does not begin on a block boundary, will pad\n");
+                       memmove(data + block_offset, data, filesz);
+                       memset(data, 0xFF, block_offset);
+                       filesz += block_offset;
+                       paddr -= block_offset;
+               }
+
+               seg->data = data;
+               seg->start = paddr;
+               seg->length = filesz;
+               seg++;
+               ctx->num_segs++;
+
+               last_end = paddr + filesz;
+               phdr++;
+       }
+       return 0;
+}
+
+// Sanity check segments and check for bootloader writes
+static int check_segs(flash_file_t *ctx, int can_write_bl) {
+       for (int i = 0; i < ctx->num_segs; i++) {
+               flash_seg_t *seg = &ctx->segments[i];
+
+               if (seg->start & (BLOCK_SIZE-1)) {
+                       fprintf(stderr, "Error: Segment is not aligned\n");
+                       return -1;
+               }
+               if (seg->start < FLASH_START) {
+                       fprintf(stderr, "Error: Segment is outside of flash bounds\n");
+                       return -1;
+               }
+               if (seg->start + seg->length > FLASH_END) {
+                       fprintf(stderr, "Error: Segment is outside of flash bounds\n");
+                       return -1;
+               }
+               if (!can_write_bl && seg->start < BOOTLOADER_END) {
+                       fprintf(stderr, "Attempted to write bootloader but bootloader writes are not enabled\n");
+                       return -1;
+               }
+       }
+       return 0;
+}
+
+// Load an ELF file and prepare it for flashing
+int flash_load(flash_file_t *ctx, const char *name, int can_write_bl)
+{
+       FILE *fd = NULL;
+       Elf32_Ehdr ehdr;
+       Elf32_Phdr *phdrs = NULL;
+       int num_phdrs;
+       int res;
+
+       fd = fopen(name, "rb");
+       if (!fd) {
+               fprintf(stderr, "Could not open file '%s': ", name);
+               perror(NULL);
+               goto fail;
+       }
+
+       fprintf(stderr, "Loading ELF file '%s'...\n", name);
+
+       if (fread(&ehdr, sizeof(ehdr), 1, fd) != 1) {
+               fprintf(stderr, "Error while reading ELF file header\n");
+               goto fail;
+       }
+       if (memcmp(ehdr.e_ident, elf_ident, sizeof(elf_ident))
+               || le32(ehdr.e_version) != 1)
+       {
+               fprintf(stderr, "Not an ELF file or wrong ELF type\n");
+               goto fail;
+       }
+       if (le16(ehdr.e_type) != ET_EXEC) {
+               fprintf(stderr, "ELF is not executable\n");
+               goto fail;
+       }
+       if (le16(ehdr.e_machine) != EM_ARM) {
+               fprintf(stderr, "Wrong ELF architecture\n");
+               goto fail;
+       }
+       if (!ehdr.e_phnum || !ehdr.e_phoff) {
+               fprintf(stderr, "ELF has no PHDRs\n");
+               goto fail;
+       }
+       if (le16(ehdr.e_phentsize) != sizeof(Elf32_Phdr)) {
+               // could be a structure padding issue...
+               fprintf(stderr, "Either the ELF file or this code is made of fail\n");
+               goto fail;
+       }
+       num_phdrs = le16(ehdr.e_phnum);
+
+       phdrs = malloc(le16(ehdr.e_phnum) * sizeof(Elf32_Phdr));
+       if (!phdrs) {
+               fprintf(stderr, "Out of memory\n");
+               goto fail;
+       }
+       if (fseek(fd, le32(ehdr.e_phoff), SEEK_SET) < 0) {
+               fprintf(stderr, "Error while reading ELF PHDRs\n");
+               goto fail;
+       }
+       if (fread(phdrs, sizeof(Elf32_Phdr), num_phdrs, fd) != num_phdrs) {
+               fprintf(stderr, "Error while reading ELF PHDRs\n");
+               goto fail;
+       }
+
+       res = build_segs_from_phdrs(ctx, fd, phdrs, num_phdrs);
+       if (res < 0)
+               goto fail;
+       res = check_segs(ctx, can_write_bl);
+       if (res < 0)
+               goto fail;
+
+       free(phdrs);
+       fclose(fd);
+       ctx->filename = name;
+       return 0;
+
+fail:
+       if (phdrs)
+               free(phdrs);
+       if (fd)
+               fclose(fd);
+       flash_free(ctx);
+       return -1;
+}
+
+// Get the state of the proxmark, backwards compatible
+static int get_proxmark_state(uint32_t *state)
+{
+       UsbCommand c;
+       c.cmd = CMD_DEVICE_INFO;
+       SendCommand(&c);
+
+       UsbCommand resp;
+       ReceiveCommand(&resp);
+
+       // Three outcomes:
+       // 1. The old bootrom code will ignore CMD_DEVICE_INFO, but respond with an ACK
+       // 2. The old os code will respond with CMD_DEBUG_PRINT_STRING and "unknown command"
+       // 3. The new bootrom and os codes will respond with CMD_DEVICE_INFO and flags
+
+       switch (resp.cmd) {
+               case CMD_ACK:
+                       *state = DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM;
+                       break;
+               case CMD_DEBUG_PRINT_STRING:
+                       *state = DEVICE_INFO_FLAG_CURRENT_MODE_OS;
+                       break;
+               case CMD_DEVICE_INFO:
+                       *state = resp.arg[0];
+                       break;
+               default:
+                       fprintf(stderr, "Error: Couldn't get proxmark state, bad response type: 0x%04x\n", resp.cmd);
+                       return -1;
+                       break;
+       }
+
+       return 0;
+}
+
+// Enter the bootloader to be able to start flashing
+static int enter_bootloader(void)
+{
+       uint32_t state;
+
+       if (get_proxmark_state(&state) < 0)
+               return -1;
+
+       if (state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) {
+               /* Already in flash state, we're done. */
+               return 0;
+       }
+
+       if (state & DEVICE_INFO_FLAG_CURRENT_MODE_OS) {
+               fprintf(stderr,"Entering bootloader...\n");
+               UsbCommand c;
+               memset(&c, 0, sizeof (c));
+
+               if ((state & DEVICE_INFO_FLAG_BOOTROM_PRESENT)
+                       && (state & DEVICE_INFO_FLAG_OSIMAGE_PRESENT))
+               {
+                       // New style handover: Send CMD_START_FLASH, which will reset the board
+                       // and enter the bootrom on the next boot.
+                       c.cmd = CMD_START_FLASH;
+                       SendCommand(&c);
+                       fprintf(stderr,"(Press and release the button only to abort)\n");
+               } else {
+                       // Old style handover: Ask the user to press the button, then reset the board
+                       c.cmd = CMD_HARDWARE_RESET;
+                       SendCommand(&c);
+                       fprintf(stderr,"Press and hold down button NOW if your bootloader requires it.\n");
+               }
+               fprintf(stderr,"Waiting for Proxmark to reappear on USB...");
+
+               CloseProxmark();
+               sleep(1);
+               while (!OpenProxmark(0)) {
+                       sleep(1);
+                       fprintf(stderr, ".");
+               }
+               fprintf(stderr," Found.\n");
+
+               return 0;
+       }
+
+       fprintf(stderr, "Error: Unknown Proxmark mode\n");
+       return -1;
+}
+
+static int wait_for_ack(void)
+{
+       UsbCommand ack;
+       ReceiveCommand(&ack);
+       if (ack.cmd != CMD_ACK) {
+               printf("Error: Unexpected reply 0x%04x (expected ACK)\n", ack.cmd);
+               return -1;
+       }
+       return 0;
+}
+
+// Go into flashing mode
+int flash_start_flashing(int enable_bl_writes)
+{
+       uint32_t state;
+
+       if (enter_bootloader() < 0)
+               return -1;
+
+       if (get_proxmark_state(&state) < 0)
+               return -1;
+
+       if (state & DEVICE_INFO_FLAG_UNDERSTANDS_START_FLASH) {
+               // This command is stupid. Why the heck does it care which area we're
+               // flashing, as long as it's not the bootloader area? The mind boggles.
+               UsbCommand c = {CMD_START_FLASH};
+
+               if (enable_bl_writes) {
+                       c.arg[0] = FLASH_START;
+                       c.arg[1] = FLASH_END;
+                       c.arg[2] = START_FLASH_MAGIC;
+               } else {
+                       c.arg[0] = BOOTLOADER_END;
+                       c.arg[1] = FLASH_END;
+                       c.arg[2] = 0;
+               }
+               SendCommand(&c);
+               return wait_for_ack();
+       } else {
+               fprintf(stderr, "Note: Your bootloader does not understand the new START_FLASH command\n");
+               fprintf(stderr, "      It is recommended that you update your bootloader\n\n");
+       }
+
+       return 0;
+}
+
+static int write_block(uint32_t address, uint8_t *data, uint32_t length)
+{
+       uint8_t block_buf[BLOCK_SIZE];
+
+       memset(block_buf, 0xFF, BLOCK_SIZE);
+       memcpy(block_buf, data, length);
+
+       UsbCommand c = {CMD_SETUP_WRITE};
+       for (int i = 0; i < 240; i += 48) {
+               memcpy(c.d.asBytes, block_buf + i, 48);
+               c.arg[0] = i / 4;
+               SendCommand(&c);
+               if (wait_for_ack() < 0)
+                       return -1;
+       }
+
+       c.cmd = CMD_FINISH_WRITE;
+       c.arg[0] = address;
+       memcpy(c.d.asBytes, block_buf+240, 16);
+       SendCommand(&c);
+       return wait_for_ack();
+}
+
+// Write a file's segments to Flash
+int flash_write(flash_file_t *ctx)
+{
+       fprintf(stderr, "Writing segments for file: %s\n", ctx->filename);
+       for (int i = 0; i < ctx->num_segs; i++) {
+               flash_seg_t *seg = &ctx->segments[i];
+
+               uint32_t length = seg->length;
+               uint32_t blocks = (length + BLOCK_SIZE - 1) / BLOCK_SIZE;
+               uint32_t end = seg->start + length;
+
+               fprintf(stderr, " 0x%08x..0x%08x [0x%x / %d blocks]",
+                       seg->start, end - 1, length, blocks);
+
+               int block = 0;
+               uint8_t *data = seg->data;
+               uint32_t baddr = seg->start;
+
+               while (length) {
+                       uint32_t block_size = length;
+                       if (block_size > BLOCK_SIZE)
+                               block_size = BLOCK_SIZE;
+
+                       if (write_block(baddr, data, block_size) < 0) {
+                               fprintf(stderr, " ERROR\n");
+                               fprintf(stderr, "Error writing block %d of %d\n", block, blocks);
+                               return -1;
+                       }
+
+                       data += block_size;
+                       baddr += block_size;
+                       length -= block_size;
+                       block++;
+                       fprintf(stderr, ".");
+               }
+               fprintf(stderr, " OK\n");
+       }
+       return 0;
+}
+
+// free a file context
+void flash_free(flash_file_t *ctx)
+{
+       if (!ctx)
+               return;
+       if (ctx->segments) {
+               for (int i = 0; i < ctx->num_segs; i++)
+                       free(ctx->segments[i].data);
+               free(ctx->segments);
+               ctx->segments = NULL;
+               ctx->num_segs = 0;
+       }
+}
+
+// just reset the unit
+int flash_stop_flashing(void) {
+       UsbCommand c = {CMD_HARDWARE_RESET};
+       SendCommand(&c);
+       return 0;
+}
diff --git a/client/hid-flasher/flash.h b/client/hid-flasher/flash.h
new file mode 100644 (file)
index 0000000..d5f47b9
--- /dev/null
@@ -0,0 +1,35 @@
+//-----------------------------------------------------------------------------
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Flashing utility functions
+//-----------------------------------------------------------------------------
+
+#ifndef __FLASH_H__
+#define __FLASH_H__
+
+#include <stdint.h>
+#include "elf.h"
+
+typedef struct {
+       void *data;
+       uint32_t start;
+       uint32_t length;
+} flash_seg_t;
+
+typedef struct {
+       const char *filename;
+       int can_write_bl;
+       int num_segs;
+       flash_seg_t *segments;
+} flash_file_t;
+
+int flash_load(flash_file_t *ctx, const char *name, int can_write_bl);
+int flash_start_flashing(int enable_bl_writes);
+int flash_write(flash_file_t *ctx);
+void flash_free(flash_file_t *ctx);
+int flash_stop_flashing(void);
+
+#endif
+
diff --git a/client/hid-flasher/flasher.c b/client/hid-flasher/flasher.c
new file mode 100644 (file)
index 0000000..a4a0e85
--- /dev/null
@@ -0,0 +1,93 @@
+//-----------------------------------------------------------------------------
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Flasher frontend tool
+//-----------------------------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "sleep.h"
+#include "proxusb.h"
+#include "flash.h"
+
+static void usage(char *argv0)
+{
+       fprintf(stderr, "Usage:   %s [-b] image.elf [image.elf...]\n\n", argv0);
+       fprintf(stderr, "\t-b\tEnable flashing of bootloader area (DANGEROUS)\n\n");
+       fprintf(stderr, "Example: %s path/to/osimage.elf path/to/fpgaimage.elf\n", argv0);
+}
+
+#define MAX_FILES 4
+
+int main(int argc, char **argv)
+{
+       int can_write_bl = 0;
+       int num_files = 0;
+       int res;
+       flash_file_t files[MAX_FILES];
+
+       memset(files, 0, sizeof(files));
+
+       if (argc < 2) {
+               usage(argv[0]);
+               return -1;
+       }
+
+       for (int i = 1; i < argc; i++) {
+               if (argv[i][0] == '-') {
+                       if (!strcmp(argv[i], "-b")) {
+                               can_write_bl = 1;
+                       } else {
+                               usage(argv[0]);
+                               return -1;
+                       }
+               } else {
+                       res = flash_load(&files[num_files], argv[i], can_write_bl);
+                       if (res < 0) {
+                               fprintf(stderr, "Error while loading %s\n", argv[i]);
+                               return -1;
+                       }
+                       fprintf(stderr, "\n");
+                       num_files++;
+               }
+       }
+
+       usb_init();
+
+       fprintf(stderr, "Waiting for Proxmark to appear on USB...");
+       while (!OpenProxmark(1)) {
+               sleep(1);
+               fprintf(stderr, ".");
+       }
+       fprintf(stderr, " Found.\n");
+
+       res = flash_start_flashing(can_write_bl);
+       if (res < 0)
+               return -1;
+
+       fprintf(stderr, "\nFlashing...\n");
+
+       for (int i = 0; i < num_files; i++) {
+               res = flash_write(&files[i]);
+               if (res < 0)
+                       return -1;
+               flash_free(&files[i]);
+               fprintf(stderr, "\n");
+       }
+
+       fprintf(stderr, "Resetting hardware...\n");
+
+       res = flash_stop_flashing();
+       if (res < 0)
+               return -1;
+
+       CloseProxmark();
+
+       fprintf(stderr, "All done.\n\n");
+       fprintf(stderr, "Have a nice day!\n");
+
+       return 0;
+}
diff --git a/client/hid-flasher/obj/.dummy b/client/hid-flasher/obj/.dummy
new file mode 100644 (file)
index 0000000..e69de29
diff --git a/client/hid-flasher/proxendian.h b/client/hid-flasher/proxendian.h
new file mode 100644 (file)
index 0000000..4a386a0
--- /dev/null
@@ -0,0 +1,46 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2010 Hector Martin "marcan" <marcan@marcansoft.com>
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Endianness convenience functions
+//-----------------------------------------------------------------------------
+
+#ifndef PROXENDIAN_H__
+#define PROXENDIAN_H__
+
+#include <stdint.h>
+
+#ifdef WIN32
+# define HOST_LITTLE_ENDIAN
+#else
+# include <sys/types.h>
+
+# if !defined(BYTE_ORDER) || (BYTE_ORDER != LITTLE_ENDIAN && BYTE_ORDER != BIG_ENDIAN)
+#  error Define BYTE_ORDER to be equal to either LITTLE_ENDIAN or BIG_ENDIAN
+# endif
+
+# if BYTE_ORDER == LITTLE_ENDIAN
+#  define HOST_LITTLE_ENDIAN
+# endif
+#endif
+
+#ifdef HOST_LITTLE_ENDIAN
+# define le16(x) (x)
+# define le32(x) (x)
+#else
+
+static inline uint16_t le16(uint16_t v)
+{
+       return (v>>8) | (v<<8);
+}
+
+static inline uint32_t le32(uint32_t v)
+{
+       return (le16(v)<<16) | (le16(v>>16));
+}
+#endif // HOST_LITTLE_ENDIAN
+
+#endif // PROXENDIAN_H__
diff --git a/client/hid-flasher/proxmark3.h b/client/hid-flasher/proxmark3.h
new file mode 100644 (file)
index 0000000..f5dd2b7
--- /dev/null
@@ -0,0 +1,17 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2009 Michael Gernoth <michael at gernoth.net>
+// Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Main binary
+//-----------------------------------------------------------------------------
+
+#ifndef PROXMARK3_H__
+#define PROXMARK3_H__
+
+#define PROXPROMPT "proxmark3> "
+
+#endif
diff --git a/client/hid-flasher/proxusb.c b/client/hid-flasher/proxusb.c
new file mode 100644 (file)
index 0000000..3c2b20b
--- /dev/null
@@ -0,0 +1,222 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2009 Michael Gernoth <michael at gernoth.net>
+// Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// USB utilities
+//-----------------------------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <usb.h>
+#include <strings.h>
+#include <errno.h>
+
+#include "sleep.h"
+#include "proxusb.h"
+#include "proxmark3.h"
+#include "usb_cmd.h"
+
+// It seems to be missing for mingw
+#ifndef ETIMEDOUT
+#define ETIMEDOUT 116
+#endif
+
+usb_dev_handle *devh = NULL;
+static unsigned int claimed_iface = 0;
+unsigned char return_on_error = 0;
+unsigned char error_occured = 0;
+extern unsigned int current_command;
+
+void SendCommand(UsbCommand *c)
+{
+  int ret;
+
+#if 0
+  printf("Sending %d bytes\n", sizeof(UsbCommand));
+#endif
+  current_command = c->cmd;
+  ret = usb_bulk_write(devh, 0x01, (char*)c, sizeof(UsbCommand), 1000);
+  if (ret<0) {
+    error_occured = 1;
+    if (return_on_error)
+      return;
+
+    fprintf(stderr, "write failed: %s!\nTrying to reopen device...\n",
+      usb_strerror());
+
+    if (devh) {
+      usb_close(devh);
+      devh = NULL;
+    }
+    while(!OpenProxmark(0)) { sleep(1); }
+    printf(PROXPROMPT);
+    fflush(NULL);
+
+    return;
+  }
+}
+
+bool ReceiveCommandPoll(UsbCommand *c)
+{
+  int ret;
+
+  memset(c, 0, sizeof (UsbCommand));
+  ret = usb_bulk_read(devh, 0x82, (char*)c, sizeof(UsbCommand), 500);
+  if (ret<0) {
+    if (ret != -ETIMEDOUT) {
+      error_occured = 1;
+      if (return_on_error)
+        return false;
+
+      fprintf(stderr, "read failed: %s(%d)!\nTrying to reopen device...\n",
+        usb_strerror(), ret);
+
+      if (devh) {
+        usb_close(devh);
+        devh = NULL;
+      }
+      while(!OpenProxmark(0)) { sleep(1); }
+      printf(PROXPROMPT);
+      fflush(NULL);
+
+      return false;
+    }
+  } else {
+    if (ret && (ret < sizeof(UsbCommand))) {
+      fprintf(stderr, "Read only %d instead of requested %d bytes!\n",
+        ret, (int)sizeof(UsbCommand));
+    }
+  }
+
+  return ret > 0;
+}
+
+void ReceiveCommand(UsbCommand *c)
+{
+//  printf("%s()\n", __FUNCTION__);
+  int retval = 0;
+  do {
+    retval = ReceiveCommandPoll(c);
+    if (retval != 1) printf("ReceiveCommandPoll returned %d\n", retval);
+  } while(retval<0);
+//  printf("recv %x\n", c->cmd);
+}
+
+usb_dev_handle* findProxmark(int verbose, unsigned int *iface)
+{
+  struct usb_bus *busses, *bus;
+  usb_dev_handle *handle = NULL;
+  struct prox_unit units[50];
+  int iUnit = 0;
+
+  usb_find_busses();
+  usb_find_devices();
+
+  busses = usb_get_busses();
+
+  for (bus = busses; bus; bus = bus->next) {
+    struct usb_device *dev;
+    
+    for (dev = bus->devices; dev; dev = dev->next) {
+      struct usb_device_descriptor *desc = &(dev->descriptor);
+
+      if ((desc->idProduct == 0x4b8f) && (desc->idVendor == 0x9ac4)) {
+        handle = usb_open(dev);
+        if (!handle) {
+          if (verbose)
+            fprintf(stderr, "open fabiled: %s!\n", usb_strerror());
+          //return NULL;
+          continue;
+        }
+        *iface = dev->config[0].interface[0].altsetting[0].bInterfaceNumber;
+
+        struct prox_unit unit = {handle, {0}};
+        usb_get_string_simple(handle, desc->iSerialNumber, unit.serial_number, sizeof(unit.serial_number));
+        units[iUnit++] = unit;
+
+        //return handle;
+      }
+    }
+  }
+
+  if (iUnit > 0) {
+    int iSelection = 0;
+
+    fprintf(stdout, "\nConnected units:\n");
+
+    for (int i = 0; i < iUnit; i++) {
+      struct usb_device * dev = usb_device(units[i].handle);
+      fprintf(stdout, "\t%d. SN: %s [%s/%s]\n", i+1, units[i].serial_number, dev->bus->dirname, dev->filename);
+    }
+    if (iUnit > 1) {
+      while (iSelection < 1 || iSelection > iUnit) {
+        fprintf(stdout, "Which unit do you want to connect to? ");
+        fscanf(stdin, "%d", &iSelection);
+        }
+      }
+    else
+      iSelection = 1;
+    iSelection --;
+
+    for (int i = 0; i < iUnit; i++) {
+      if (iSelection == i) continue;
+      usb_close(units[i].handle);
+      units[i].handle = NULL;
+    }
+
+    return units[iSelection].handle;
+  }
+
+  return NULL;
+}
+
+usb_dev_handle* OpenProxmark(int verbose)
+{
+  int ret;
+  usb_dev_handle *handle = NULL;
+  unsigned int iface;
+
+  handle = findProxmark(verbose, &iface);
+  if (!handle)
+    return NULL;
+
+#ifdef __linux__
+  /* detach kernel driver first */
+  ret = usb_detach_kernel_driver_np(handle, iface);
+  /* don't complain if no driver attached */
+  if (ret<0 && ret != -61 && verbose)
+    fprintf(stderr, "detach kernel driver failed: (%d) %s!\n", ret, usb_strerror());
+#endif
+
+  // Needed for Windows. Optional for Mac OS and Linux
+  ret = usb_set_configuration(handle, 1);
+  if (ret < 0) {
+    if (verbose)
+      fprintf(stderr, "configuration set failed: %s!\n", usb_strerror());
+    return NULL;
+  }
+
+  ret = usb_claim_interface(handle, iface);
+  if (ret < 0) {
+    if (verbose)
+      fprintf(stderr, "claim failed: %s!\n", usb_strerror());
+    return NULL;
+  }
+  claimed_iface = iface;
+  devh = handle;
+  return handle;
+}
+
+void CloseProxmark(void)
+{
+  usb_release_interface(devh, claimed_iface);
+  usb_close(devh);
+  devh = NULL;
+}
diff --git a/client/hid-flasher/proxusb.h b/client/hid-flasher/proxusb.h
new file mode 100644 (file)
index 0000000..5845888
--- /dev/null
@@ -0,0 +1,34 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// USB utilities
+//-----------------------------------------------------------------------------
+
+#ifndef PROXUSB_H__
+#define PROXUSB_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <usb.h>
+#include "usb_cmd.h"
+
+extern unsigned char return_on_error;
+extern unsigned char error_occured;
+
+void SendCommand(UsbCommand *c);
+bool ReceiveCommandPoll(UsbCommand *c);
+void ReceiveCommand(UsbCommand *c);
+struct usb_dev_handle* FindProxmark(int verbose, unsigned int *iface);
+struct usb_dev_handle* OpenProxmark(int verbose);
+void CloseProxmark(void);
+
+struct prox_unit {
+  usb_dev_handle *handle;
+  char serial_number[256];
+};
+
+#endif
diff --git a/client/hid-flasher/sleep.h b/client/hid-flasher/sleep.h
new file mode 100644 (file)
index 0000000..81f4e06
--- /dev/null
@@ -0,0 +1,24 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// platform-independant sleep macros
+//-----------------------------------------------------------------------------
+
+#ifndef SLEEP_H__
+#define SLEEP_H__
+
+#ifdef WIN32
+#include <windows.h>
+#define sleep(n) Sleep(1000 * n)
+#define msleep(n) Sleep(n)
+#else
+#include <unistd.h>
+#define msleep(n) usleep(1000 * n)
+#endif
+
+#endif
+
diff --git a/client/hid-flasher/usb_cmd.h b/client/hid-flasher/usb_cmd.h
new file mode 100644 (file)
index 0000000..a7552b3
--- /dev/null
@@ -0,0 +1,165 @@
+//-----------------------------------------------------------------------------
+// Jonathan Westhues, Mar 2006
+// Edits by Gerhard de Koning Gans, Sep 2007
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Definitions for all the types of commands that may be sent over USB; our
+// own protocol.
+//-----------------------------------------------------------------------------
+
+#ifndef __USB_CMD_H
+#define __USB_CMD_H
+#ifdef _MSC_VER
+typedef DWORD uint32_t;
+typedef BYTE uint8_t;
+#define PACKED
+// stuff
+#else
+#include <stdint.h>
+#include <stdbool.h>
+#define PACKED __attribute__((packed))
+#endif
+
+typedef struct {
+       uint32_t        cmd;
+       uint32_t        arg[3];
+       union {
+               uint8_t         asBytes[48];
+               uint32_t        asDwords[12];
+       } d;
+} PACKED UsbCommand;
+
+// For the bootloader
+#define CMD_DEVICE_INFO                                                   0x0000
+#define CMD_SETUP_WRITE                                                   0x0001
+#define CMD_FINISH_WRITE                                                  0x0003
+#define CMD_HARDWARE_RESET                                                0x0004
+#define CMD_START_FLASH                                                   0x0005
+#define CMD_NACK                                                          0x00fe
+#define CMD_ACK                                                           0x00ff
+
+// For general mucking around
+#define CMD_DEBUG_PRINT_STRING                                            0x0100
+#define CMD_DEBUG_PRINT_INTEGERS                                          0x0101
+#define CMD_DEBUG_PRINT_BYTES                                             0x0102
+#define CMD_LCD_RESET                                                     0x0103
+#define CMD_LCD                                                           0x0104
+#define CMD_BUFF_CLEAR                                                    0x0105
+#define CMD_READ_MEM                                                      0x0106
+#define CMD_VERSION                                                       0x0107
+
+// For low-frequency tags
+#define CMD_READ_TI_TYPE                                                  0x0202
+#define CMD_WRITE_TI_TYPE                                                 0x0203
+#define CMD_DOWNLOADED_RAW_BITS_TI_TYPE                                   0x0204
+#define CMD_ACQUIRE_RAW_ADC_SAMPLES_125K                                  0x0205
+#define CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K                         0x0206
+#define CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K                                 0x0207
+#define CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K                               0x0208
+#define CMD_DOWNLOADED_SIM_SAMPLES_125K                                   0x0209
+#define CMD_SIMULATE_TAG_125K                                             0x020A
+#define CMD_HID_DEMOD_FSK                                                 0x020B
+#define CMD_HID_SIM_TAG                                                   0x020C
+#define CMD_SET_LF_DIVISOR                                                0x020D
+#define CMD_LF_SIMULATE_BIDIR                                             0x020E
+#define CMD_SET_ADC_MUX                                                   0x020F
+#define CMD_HID_CLONE_TAG                                                 0x0210
+#define CMD_EM410X_WRITE_TAG                                              0x0211
+#define CMD_INDALA_CLONE_TAG                                              0x0212
+// for 224 bits UID
+#define CMD_INDALA_CLONE_TAG_L                                            0x0213
+
+/* CMD_SET_ADC_MUX: ext1 is 0 for lopkd, 1 for loraw, 2 for hipkd, 3 for hiraw */
+
+// For the 13.56 MHz tags
+#define CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693                             0x0300
+#define CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443                             0x0301
+#define CMD_READ_SRI512_TAG                                               0x0303
+#define CMD_READ_SRIX4K_TAG                                               0x0304
+#define CMD_READER_ISO_15693                                              0x0310
+#define CMD_SIMTAG_ISO_15693                                              0x0311
+#define CMD_RECORD_RAW_ADC_SAMPLES_ISO_15693                              0x0312
+#define CMD_ISO_15693_COMMAND                                             0x0313
+#define CMD_ISO_15693_COMMAND_DONE                                        0x0314
+#define CMD_ISO_15693_FIND_AFI                                            0x0315
+#define CMD_ISO_15693_DEBUG                                               0x0316
+
+// For Hitag2 transponders
+#define CMD_SNOOP_HITAG                                                   0x0370
+#define CMD_SIMULATE_HITAG                                                0x0371
+#define CMD_READER_HITAG                                                  0x0372
+
+#define CMD_SIMULATE_TAG_HF_LISTEN                                        0x0380
+#define CMD_SIMULATE_TAG_ISO_14443                                        0x0381
+#define CMD_SNOOP_ISO_14443                                               0x0382
+#define CMD_SNOOP_ISO_14443a                                              0x0383
+#define CMD_SIMULATE_TAG_ISO_14443a                                       0x0384
+#define CMD_READER_ISO_14443a                                             0x0385
+#define CMD_SIMULATE_TAG_LEGIC_RF                                         0x0387
+#define CMD_READER_LEGIC_RF                                               0x0388
+#define CMD_WRITER_LEGIC_RF                                               0x0389
+#define CMD_EPA_PACE_COLLECT_NONCE                                        0x038A
+
+#define CMD_SNOOP_ICLASS                                                  0x0392
+#define CMD_SIMULATE_TAG_ICLASS                                           0x0393
+#define CMD_READER_ICLASS                                                 0x0394
+
+// For measurements of the antenna tuning
+#define CMD_MEASURE_ANTENNA_TUNING                                        0x0400
+#define CMD_MEASURE_ANTENNA_TUNING_HF                                     0x0401
+#define CMD_MEASURED_ANTENNA_TUNING                                       0x0410
+#define CMD_LISTEN_READER_FIELD                                           0x0420
+
+// For direct FPGA control
+#define CMD_FPGA_MAJOR_MODE_OFF                                           0x0500
+
+// For mifare commands
+#define CMD_MIFARE_SET_DBGMODE                                            0x0600
+#define CMD_MIFARE_EML_MEMCLR                                             0x0601
+#define CMD_MIFARE_EML_MEMSET                                             0x0602
+#define CMD_MIFARE_EML_MEMGET                                             0x0603
+#define CMD_MIFARE_EML_CARDLOAD                                           0x0604
+#define CMD_MIFARE_EML_CSETBLOCK                                          0x0605
+#define CMD_MIFARE_EML_CGETBLOCK                                          0x0606
+
+#define CMD_SIMULATE_MIFARE_CARD                                          0x0610
+
+#define CMD_READER_MIFARE                                                 0x0611
+#define CMD_MIFARE_NESTED                                                 0x0612
+
+#define CMD_MIFARE_READBL                                                 0x0620
+#define CMD_MIFARE_READSC                                                 0x0621
+#define CMD_MIFARE_WRITEBL                                                0x0622
+#define CMD_MIFARE_CHKKEYS                                                0x0623
+
+#define CMD_MIFARE_SNIFFER                                                0x0630
+
+#define CMD_UNKNOWN                                                       0xFFFF
+
+// CMD_DEVICE_INFO response packet has flags in arg[0], flag definitions:
+/* Whether a bootloader that understands the common_area is present */
+#define DEVICE_INFO_FLAG_BOOTROM_PRESENT               (1<<0)
+
+/* Whether a osimage that understands the common_area is present */
+#define DEVICE_INFO_FLAG_OSIMAGE_PRESENT               (1<<1)
+
+/* Set if the bootloader is currently executing */
+#define DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM          (1<<2)
+
+/* Set if the OS is currently executing */
+#define DEVICE_INFO_FLAG_CURRENT_MODE_OS               (1<<3)
+
+/* Set if this device understands the extend start flash command */
+#define DEVICE_INFO_FLAG_UNDERSTANDS_START_FLASH       (1<<4)
+
+/* CMD_START_FLASH may have three arguments: start of area to flash,
+   end of area to flash, optional magic.
+   The bootrom will not allow to overwrite itself unless this magic
+   is given as third parameter */
+
+#define START_FLASH_MAGIC 0x54494f44 // 'DOIT'
+
+#endif
Impressum, Datenschutz