git.zerfleddert.de Git - proxmark3-svn/blob

1 //-----------------------------------------------------------------------------

3 //

4 // This code is licensed to you under the terms of the GNU GPL, version 2 or,

5 // at your option, any later version. See the LICENSE.txt file for the text of

6 // the license.

7 //-----------------------------------------------------------------------------

8 // Graph utilities

9 //-----------------------------------------------------------------------------

11 #include <stdio.h>

12 #include <stdbool.h>

13 #include <string.h>

14 #include "ui.h"

15 #include "graph.h"

16 #include "lfdemod.h"

17 #include "cmddata.h" //for g_debugmode

19 int GraphBuffer[MAX_GRAPH_TRACE_LEN];

20 int GraphTraceLen;

22 int s_Buff[MAX_GRAPH_TRACE_LEN];

24 /* write a manchester bit to the graph */

 void AppendGraph(int redraw, int clock, int bit)

26 {

27 int i;

28 //set first half the clock bit (all 1's or 0's for a 0 or 1 bit)

   for (i = 0; i < (int)(clock / 2); ++i)

30 GraphBuffer[GraphTraceLen++] = bit ;

31 //set second half of the clock bit (all 0's or 1's for a 0 or 1 bit)

   for (i = (int)(clock / 2); i < clock; ++i)

     GraphBuffer[GraphTraceLen++] = bit ^ 1;

35 if (redraw)

36 RepaintGraphWindow();

37 }

39 // clear out our graph window

 int ClearGraph(int redraw)

41 {

42 int gtl = GraphTraceLen;

   memset(GraphBuffer, 0x00, GraphTraceLen);

45 GraphTraceLen = 0;

47 if (redraw)

48 RepaintGraphWindow();

50 return gtl;

51 }

52 // option '1' to save GraphBuffer any other to restore

 void save_restoreGB(uint8_t saveOpt)

54 {

55 static int SavedGB[MAX_GRAPH_TRACE_LEN];

56 static int SavedGBlen=0;

57 static bool GB_Saved = false;

58 static int SavedGridOffsetAdj=0;

         if (saveOpt == GRAPH_SAVE) { //save

                 memcpy(SavedGB, GraphBuffer, sizeof(GraphBuffer));

62 SavedGBlen = GraphTraceLen;

63 GB_Saved=true;

64 SavedGridOffsetAdj = GridOffset;

         } else if (GB_Saved) { //restore

                 memcpy(GraphBuffer, SavedGB, sizeof(GraphBuffer));

67 GraphTraceLen = SavedGBlen;

68 GridOffset = SavedGridOffsetAdj;

69 RepaintGraphWindow();

70 }

71 return;

72 }

74 // DETECT CLOCK NOW IN LFDEMOD.C

 void setGraphBuf(uint8_t *buff, size_t size)

77 {

         if ( buff == NULL ) return;

80 uint16_t i = 0;

81 if ( size > MAX_GRAPH_TRACE_LEN )

82 size = MAX_GRAPH_TRACE_LEN;

83 ClearGraph(0);

         for (; i < size; ++i){

                 GraphBuffer[i]=buff[i]-128;

86 }

87 GraphTraceLen=size;

88 RepaintGraphWindow();

89 return;

90 }

 size_t getFromGraphBuf(uint8_t *buff)

92 {

         if (buff == NULL ) return 0;

94 uint32_t i;

         for (i=0;i<GraphTraceLen;++i){

                 if (GraphBuffer[i]>127) GraphBuffer[i]=127; //trim

                 if (GraphBuffer[i]<-127) GraphBuffer[i]=-127; //trim

                 buff[i]=(uint8_t)(GraphBuffer[i]+128);

99 }

100 return i;

101 }

102

103 // A simple test to see if there is any data inside Graphbuffer.

104 bool HasGraphData(){

105

         if ( GraphTraceLen <= 0) {

107 PrintAndLog("No data available, try reading something first");

108 return false;

109 }

110 return true;

111 }

112

113 // Detect high and lows in Grapbuffer.

114 // Only loops the first 256 values.

 void DetectHighLowInGraph(int *high, int *low, bool addFuzz) {

116

117 uint8_t loopMax = 255;

118 if ( loopMax > GraphTraceLen)

119 loopMax = GraphTraceLen;

120

         for (uint8_t i = 0; i < loopMax; ++i) {

                 if (GraphBuffer[i] > *high)

123 *high = GraphBuffer[i];

                 else if (GraphBuffer[i] < *low)

125 *low = GraphBuffer[i];

126 }

127

128 //12% fuzz in case highs and lows aren't clipped

129 if (addFuzz) {

                 *high = (int)(*high * .88);

                 *low  = (int)(*low  * .88);

132 }

133 }

134

135 // Get or auto-detect ask clock rate

 int GetAskClock(const char str[], bool printAns, bool verbose)

137 {

138 int clock;

         sscanf(str, "%i", &clock);

         if (!strcmp(str, ""))

141 clock = 0;

142

         if (clock != 0) 

144 return clock;

145 // Auto-detect clock

         uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};

         size_t size = getFromGraphBuf(grph);

         if (size == 0) {

149 if (verbose)

150 PrintAndLog("Failed to copy from graphbuffer");

151 return -1;

152 }

153 //, size_t *ststart, size_t *stend

         size_t ststart = 0, stend = 0;

         bool st = DetectST(grph, &size, &clock, &ststart, &stend);

156 int start = stend;

         if (st == false) {

                 start = DetectASKClock(grph, size, &clock, 20);

159 }

160 setClockGrid(clock, start);

161 // Only print this message if we're not looping something

162 if (printAns || g_debugMode) {

                 PrintAndLog("Auto-detected clock rate: %d, Best Starting Position: %d", clock, start);

164 }

165 return clock;

166 }

167

 uint8_t GetPskCarrier(const char str[], bool printAns, bool verbose)

169 {

170 uint8_t carrier=0;

         uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};

         size_t size = getFromGraphBuf(grph);

         if ( size == 0 ) {

174 if (verbose)

175 PrintAndLog("Failed to copy from graphbuffer");

176 return 0;

177 }

         uint16_t fc = countFC(grph,size,0);

179 carrier = fc & 0xFF;

         if (carrier != 2 && carrier != 4 && carrier != 8) return 0;

         if ((fc>>8) == 10 && carrier == 8) return 0;

182 // Only print this message if we're not looping something

183 if (printAns) {

                 PrintAndLog("Auto-detected PSK carrier rate: %d", carrier);

185 }

186 return carrier;

187 }

188

 int GetPskClock(const char str[], bool printAns, bool verbose)

190 {

191 int clock;

         sscanf(str, "%i", &clock);

         if (!strcmp(str, "")) 

194 clock = 0;

195

         if (clock!=0) 

197 return clock;

198 // Auto-detect clock

         uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};

         size_t size = getFromGraphBuf(grph);

         if ( size == 0 ) {

202 if (verbose)

203 PrintAndLog("Failed to copy from graphbuffer");

204 return -1;

205 }

206 size_t firstPhaseShiftLoc = 0;

         uint8_t curPhase = 0, fc = 0;

         clock = DetectPSKClock(grph, size, 0, &firstPhaseShiftLoc, &curPhase, &fc);

209 setClockGrid(clock, firstPhaseShiftLoc);

210 // Only print this message if we're not looping something

211 if (printAns){

                 PrintAndLog("Auto-detected clock rate: %d", clock);

213 }

214 return clock;

215 }

216

 uint8_t GetNrzClock(const char str[], bool printAns, bool verbose)

218 {

219 int clock;

         sscanf(str, "%i", &clock);

         if (!strcmp(str, ""))

222 clock = 0;

223

         if (clock!=0) 

225 return clock;

226 // Auto-detect clock

         uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};

         size_t size = getFromGraphBuf(grph);

         if ( size == 0 ) {

230 if (verbose)

231 PrintAndLog("Failed to copy from graphbuffer");

232 return -1;

233 }

234 size_t clkStartIdx = 0;

         clock = DetectNRZClock(grph, size, 0, &clkStartIdx);

236 setClockGrid(clock, clkStartIdx);

237 // Only print this message if we're not looping something

238 if (printAns){

                 PrintAndLog("Auto-detected clock rate: %d", clock);

240 }

241 return clock;

242 }

243 //by marshmellow

244 //attempt to detect the field clock and bit clock for FSK

 uint8_t GetFskClock(const char str[], bool printAns, bool verbose)

246 {

247 int clock;

         sscanf(str, "%i", &clock);

         if (!strcmp(str, ""))

250 clock = 0;

         if (clock != 0) return (uint8_t)clock;

252

253

         uint8_t fc1=0, fc2=0, rf1=0;

255 int firstClockEdge = 0;

         uint8_t ans = fskClocks(&fc1, &fc2, &rf1, verbose, &firstClockEdge);

         if (ans == 0) return 0;

         if ((fc1==10 && fc2==8) || (fc1==8 && fc2==5)){

                 if (printAns) PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1);

260 setClockGrid(rf1, firstClockEdge);

261 return rf1;

262 }

263 if (verbose){

264 PrintAndLog("DEBUG: unknown fsk field clock detected");

                 PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1);

266 }

267 return 0;

268 }

 uint8_t fskClocks(uint8_t *fc1, uint8_t *fc2, uint8_t *rf1, bool verbose, int *firstClockEdge)

270 {

         uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};

         size_t size = getFromGraphBuf(BitStream);

         if (size==0) return 0;

         uint16_t ans = countFC(BitStream, size, 1); 

         if (ans==0) {

                 if (verbose || g_debugMode) PrintAndLog("DEBUG: No data found");

277 return 0;

278 }

         *fc1 = (ans >> 8) & 0xFF;

         *fc2 = ans & 0xFF;

281 //int firstClockEdge = 0;

         *rf1 = detectFSKClk(BitStream, size, *fc1, *fc2, firstClockEdge);

         if (*rf1==0) {

                 if (verbose || g_debugMode) PrintAndLog("DEBUG: Clock detect error");

285 return 0;

286 }

287 return 1;

288 }

 bool graphJustNoise(int *BitStream, int size)

290 {

         static const uint8_t THRESHOLD = 15; //might not be high enough for noisy environments

292 //test samples are not just noise

293 bool justNoise1 = 1;

         for(int idx=0; idx < size && justNoise1 ;idx++){

295 justNoise1 = BitStream[idx] < THRESHOLD;

296 }

297 return justNoise1;

298 }