pyxcp 0.22.1__cp38-cp38-macosx_13_0_x86_64.whl

pyxcp/asam/types.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python
+import struct
+
+
+INTEL = "<"
+MOTOROLA = ">"
+
+"""
+    A_VOID: pseudo type for non-existing elements
+    A_BIT: one bit
+    A_ASCIISTRING: string, ISO-8859-1 encoded
+    A_UTF8STRING: string, UTF-8 encoded
+    A_UNICODE2STRING: string, UCS-2 encoded
+    A_BYTEFIELD: Field of bytes
+"""
+
+
+class AsamBaseType:
+    """Base class for ASAM codecs.
+
+    Note
+    ----
+    Always use derived classes.
+    """
+
+    def __init__(self, byteorder):
+        """
+
+        Parameters
+        ----------
+        byteorder: char {'<', '>'}
+          - '<' Little-endian
+          - '>' Big-endian
+        """
+        if byteorder not in ("<", ">"):
+            raise ValueError("Invalid byteorder.")
+        self.byteorder = byteorder
+
+    def encode(self, value):
+        """Encode a value.
+
+        Encode means convert a value, eg. an integer, to a byte-string.
+
+        Parameters
+        ----------
+        value: data-type
+          data-type is determined by derived class.
+
+        Returns
+        -------
+        bytes
+          Encoded value.
+        """
+        return struct.pack(f"{self.byteorder}{self.FMT}", value)
+
+    def decode(self, value):
+        """Decode a value.
+
+        Decode means convert a byte-string to a meaningful data-type, eg. an
+        integer.
+
+        Parameters
+        ----------
+        value:  bytes
+
+        Returns
+        -------
+        data-type
+          data-type is determined by derived class.
+        """
+        return struct.unpack(f"{self.byteorder}{self.FMT}", bytes(value))[0]
+
+
+class A_Uint8(AsamBaseType):
+    """ASAM A_UINT8 codec."""
+
+    FMT = "B"
+
+
+class A_Uint16(AsamBaseType):
+    """ASAM A_UINT16 codec."""
+
+    FMT = "H"
+
+
+class A_Uint32(AsamBaseType):
+    """ASAM A_UINT32 codec."""
+
+    FMT = "I"
+
+
+class A_Uint64(AsamBaseType):
+    """ASAM A_UINT64 codec."""
+
+    FMT = "Q"
+
+
+class A_Int8(AsamBaseType):
+    """ASAM A_INT8 codec."""
+
+    FMT = "b"
+
+
+class A_Int16(AsamBaseType):
+    """ASAM A_INT16 codec."""
+
+    FMT = "h"
+
+
+class A_Int32(AsamBaseType):
+    """ASAM A_INT32 codec."""
+
+    FMT = "i"
+
+
+class A_Int64(AsamBaseType):
+    """ASAM A_INT64 codec."""
+
+    FMT = "q"
+
+
+class A_Float32(AsamBaseType):
+    """ASAM A_FLOAT32 codec."""
+
+    FMT = "f"
+
+
+class A_Float64(AsamBaseType):
+    """ASAM A_FLOAT64 codec."""
+
+    FMT = "d"

pyxcp/asamkeydll.c

@@ -0,0 +1,116 @@
+
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#if defined(_WIN32)
+#include <windows.h>
+
+#define LOAD_LIB(name)  LoadLibrary((name))
+#define GET_SYM(module, sym) GetProcAddress((module), (sym))
+
+#else
+
+#define _GNU_SOURCE
+#include <dlfcn.h>
+
+typedef uint8_t BYTE;
+typedef uint32_t DWORD;
+typedef void * HANDLE;
+
+#define LOAD_LIB(name)  dlopen((name), RTLD_LAZY)
+#define GET_SYM(module, sym) dlsym((module), (sym))
+
+
+#endif
+
+
+
+
+#define NP_BUFSIZE  (4096)
+#define KEY_BUFSIZE (255)
+
+#define ERR_OK                      (0)
+
+#define ERR_INVALID_CMD_LINE        (2)
+
+#define ERR_COULD_NOT_LOAD_DLL      (16)
+#define ERR_COULD_NOT_LOAD_FUNC     (17)
+
+
+char dllname[NP_BUFSIZE] = {0};
+
+DWORD GetKey(char * const dllName, BYTE privilege, BYTE lenSeed, BYTE * seed, BYTE * lenKey, BYTE * key);
+void hexlify(uint8_t const * const buf, uint16_t len);
+
+typedef DWORD (*XCP_GetAvailablePrivilegesType)(BYTE * privilege);
+typedef DWORD (*XCP_ComputeKeyFromSeedType)(BYTE privilege, BYTE lenSeed, BYTE *seed, BYTE * lenKey, BYTE * key);
+
+
+uint8_t keyBuffer[KEY_BUFSIZE] = {0};
+uint8_t seedBuffer[KEY_BUFSIZE] = {0};
+char nameBuffer[KEY_BUFSIZE] = {0};
+uint8_t keylen = KEY_BUFSIZE;
+uint8_t seedlen = 0;
+
+
+void hexlify(uint8_t const * const buf, uint16_t len)
+{
+    for (uint16_t idx = 0; idx < len; ++idx) {
+        printf("%02X", buf[idx]);
+    }
+}
+
+DWORD GetKey(char * const dllName, BYTE privilege, BYTE lenSeed, BYTE * seed, BYTE * lenKey, BYTE * key)
+{
+    HANDLE hModule = LOAD_LIB(dllName);
+    XCP_ComputeKeyFromSeedType XCP_ComputeKeyFromSeed;
+
+    if (hModule != NULL) {
+        XCP_ComputeKeyFromSeed = (XCP_ComputeKeyFromSeedType)GET_SYM(hModule, "XCP_ComputeKeyFromSeed");
+        //printf("fp: %p\n", XCP_ComputeKeyFromSeed);
+        if (XCP_ComputeKeyFromSeed != NULL) {
+            return XCP_ComputeKeyFromSeed(privilege, lenSeed, seed, lenKey, key);
+        } else {
+            return ERR_COULD_NOT_LOAD_FUNC;
+        }
+    } else {
+        return ERR_COULD_NOT_LOAD_DLL;
+    }
+    return ERR_OK;
+}
+
+
+
+int main(int argc, char ** argv)
+{
+    BYTE privilege = 0;
+    int idx;
+    DWORD res;
+    char cbuf[3] = {0};
+
+    for (idx = 1; idx < argc; ++idx) {
+        if (idx == 1) {
+            strcpy(dllname, argv[idx]);
+        } else if (idx == 2) {
+            privilege = atoi(argv[idx]);
+        } else if (idx == 3) {
+            strcpy(nameBuffer, argv[idx]);
+        }
+    }
+
+    seedlen = strlen(nameBuffer) >> 1;
+    for (idx = 0; idx < seedlen; ++idx) {
+        cbuf[0] = nameBuffer[idx * 2];
+        cbuf[1] = nameBuffer[(idx * 2) + 1 ];
+        cbuf[2] = '\x00';
+        seedBuffer[idx] = strtol(cbuf, 0, 16);
+    }
+
+    res = GetKey((char *)&dllname, privilege, seedlen, (BYTE *)&seedBuffer, &keylen, (BYTE *)&keyBuffer);
+    if (res == 0) {
+        hexlify(keyBuffer, keylen);
+    }
+}

pyxcp/asamkeydll.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+gcc -O3 -Wall asamkeydll.c -ldl  -o asamkeydll