MIKAI
Library to modify content of a Mykey
mikai.c
Go to the documentation of this file.
1 /*
2  * @author Lilz <https://telegram.me/Lilz73>
3  * @copyright 2020-2021 Lilz <https://telegram.me/Lilz73>
4  * @license MIKAI LICENSE
5  *
6  * This file is part of MIKAI.
7  *
8  * MIKAI is free software: you can redistribute it and/or modify
9  * it under the terms of the MIKAI License, as published by
10  * Lilz along with this program and available on "MIKAI Download" Telegram channel
11  * <https://telegram.me/mikaidownload>.
12  *
13  * MIKAI is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY.
15  *
16  * You should have received a copy of the MIKAI License along
17  * with MIKAI.
18  * If not, see <https://telegram.me/mikaidownload>.
19  */
20 
21 #include <mikai/mikai.h>
22 #include "srix/srix.h"
23 #include "mikai-internal.h"
24 #include "mikai-error.h"
25 
26 const char *MikaiVersion() {
27  return "4.0.0";
28 }
29 
31  /* Allocate mikai struct and check if there are errors */
32  MyKey *target = malloc(sizeof(MyKey));
33  if (!target) return (void *) 0;
34 
35  /* Allocate Srix struct and check if there are errors */
36  target->srix4k = SrixNew();
37  if (!target->srix4k) {
38  MikaiDelete(target);
39  return (void *) 0;
40  }
41 
42  /* Reset MyKey ID */
43  *SrixGetBlock(target->srix4k, 0x07) = 0;
44 
45  /* Reset error */
46  target->error = MIKAI_NO_ERROR;
47  target->error.message = "";
48 
49  return target;
50 }
51 
52 const char *MikaiInit(MyKey **key, uint32_t dump[const SRIX4K_BLOCKS], uint64_t selection) {
53  if (!key) {
54  return "pointer is null";
55  }
56 
57  if (!*key) {
58  /* Pointer to mikai pointer is null */
59  *key = MikaiNew();
60  if (!*key) {
61  return "unable to allocate memory for MyKey";
62  }
63  }
64 
65  if (dump) {
66  /* Initialize Srix from memory */
67  SrixMemoryInit((*key)->srix4k, dump, selection);
68  } else {
69  /* Initialize Srix from NFC */
70  (*key)->error = SrixNfcInit((*key)->srix4k, selection);
71  if ((*key)->error.errorType != MIKAI_SUCCESS) {
72  const char *error = (*key)->error.message;
73  MikaiDelete(*key);
74  return error;
75  }
76  }
77 
78  /* Calculate MyKey keys */
79  void calculateEncryptionKey(MyKey *key);
81 
82  /* Return pointer */
83  return (void *) 0;
84 }
85 
86 void MikaiDelete(MyKey *key) {
87  SrixDelete(key->srix4k);
88  free(key);
89 }
90 
91 const char *MikaiGetLatestError(MyKey key[static 1]) {
92  const char *message = key->error.message;
93 
94  /* Reset error */
95  key->error = MIKAI_NO_ERROR;
96  key->error.message = "";
97 
98  return message;
99 }
100 
101 size_t MyKeyGetReadersCount(MyKey key[static 1]) {
102  return NfcGetReadersCount(key->srix4k);
103 }
104 
105 char *MyKeyGetReaderDescription(MyKey key[static 1], int reader) {
106  return NfcGetDescription(key->srix4k, reader);
107 }
108 
109 int MyKeyWriteAll(MyKey key[static 1]) {
110  key->error = SrixWriteBlocks(key->srix4k);
111  return key->error.errorType;
112 }
MikaiError::errorType
MikaiErrorCode errorType
Definition: mikai-error.h:41
MyKeyWriteAll
int MyKeyWriteAll(MyKey key[static 1])
Definition: mikai.c:109
mikai.h
NfcGetReadersCount
size_t NfcGetReadersCount(Srix target[static 1])
Definition: srix.c:140
SrixNfcInit
MikaiError SrixNfcInit(Srix target[static 1], int reader)
Definition: srix.c:148
SrixDelete
void SrixDelete(Srix target[static 1])
Definition: srix.c:134
SrixNew
Srix * SrixNew()
Create a new Srix and set its default values.
Definition: srix.c:123
MyKey
Struct that represents a MyKey.
Definition: mikai-internal.h:31
MikaiGetLatestError
const char * MikaiGetLatestError(MyKey key[static 1])
Definition: mikai.c:91
mikai-error.h
MikaiNew
MyKey * MikaiNew()
Create a new MyKey instance.
Definition: mikai.c:30
MyKey::error
MikaiError error
Definition: mikai-internal.h:34
MyKeyGetReaderDescription
char * MyKeyGetReaderDescription(MyKey key[static 1], int reader)
Definition: mikai.c:105
MIKAI_SUCCESS
@ MIKAI_SUCCESS
Definition: mikai-error.h:31
MIKAI_NO_ERROR
#define MIKAI_NO_ERROR
Definition: mikai-error.h:45
srix.h
MikaiInit
const char * MikaiInit(MyKey **key, uint32_t dump[const SRIX4K_BLOCKS], uint64_t selection)
Definition: mikai.c:52
SrixMemoryInit
void SrixMemoryInit(Srix target[static 1], uint32_t eeprom[const static SRIX4K_BLOCKS], uint64_t uid)
Definition: srix.c:168
MikaiError::message
const char * message
Definition: mikai-error.h:42
SrixGetBlock
uint32_t * SrixGetBlock(Srix target[static 1], uint8_t blockNum)
Definition: srix.c:188
mikai-internal.h
SRIX4K_BLOCKS
#define SRIX4K_BLOCKS
Definition: mikai.h:30
calculateEncryptionKey
void calculateEncryptionKey(MyKey key[static 1])
Calculate the encryption key and save the result in mikai struct.
Definition: mykey.c:104
MikaiDelete
void MikaiDelete(MyKey *key)
Delete a MyKey.
Definition: mikai.c:86
SrixWriteBlocks
MikaiError SrixWriteBlocks(Srix target[static 1])
Definition: srix.c:197
MikaiVersion
const char * MikaiVersion()
Get current version of mikai as string.
Definition: mikai.c:26
MyKey::srix4k
Srix * srix4k
Definition: mikai-internal.h:33
NfcGetDescription
char * NfcGetDescription(Srix *target, int reader)
Function that return specified nfc reader description (connection string).
Definition: srix.c:144
MyKeyGetReadersCount
size_t MyKeyGetReadersCount(MyKey key[static 1])
Definition: mikai.c:101