Dariaceli's Git
Browse code

Change sha3 implementation used. Initial unsaved data API.

Dario Rodriguez authored on 02/03/2019 16:12:12
Showing 1 changed files
keccak/SnP-Relaned.h
History View file @ e6ebc6a
1 1 
deleted file mode 100644
... ... 
@@ -1,134 +0,0 @@
1 
-/*
2 
-Implementation by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
3 
-Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer, hereby
4 
-denoted as "the implementer".
5 
-
6 
-For more information, feedback or questions, please refer to our websites:
7 
-http://keccak.noekeon.org/
8 
-http://keyak.noekeon.org/
9 
-http://ketje.noekeon.org/
10 
-
11 
-To the extent possible under law, the implementer has waived all copyright
12 
-and related or neighboring rights to the source code in this file.
13 
-http://creativecommons.org/publicdomain/zero/1.0/
14 
-*/
15 
-
16 
-#ifndef _SnP_Relaned_h_
17 
-#define _SnP_Relaned_h_
18 
-
19 
-#define SnP_AddBytes(state, data, offset, length, SnP_AddLanes, SnP_AddBytesInLane, SnP_laneLengthInBytes) \
20 
-    { \
21 
-        if ((offset) == 0) { \
22 
-            SnP_AddLanes(state, data, (length)/SnP_laneLengthInBytes); \
23 
-            SnP_AddBytesInLane(state, \
24 
-                (length)/SnP_laneLengthInBytes, \
25 
-                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
26 
-                0, \
27 
-                (length)%SnP_laneLengthInBytes); \
28 
-        } \
29 
-        else { \
30 
-            unsigned int _sizeLeft = (length); \
31 
-            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
32 
-            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
33 
-            const unsigned char *_curData = (data); \
34 
-            while(_sizeLeft > 0) { \
35 
-                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
36 
-                if (_bytesInLane > _sizeLeft) \
37 
-                    _bytesInLane = _sizeLeft; \
38 
-                SnP_AddBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
39 
-                _sizeLeft -= _bytesInLane; \
40 
-                _lanePosition++; \
41 
-                _offsetInLane = 0; \
42 
-                _curData += _bytesInLane; \
43 
-            } \
44 
-        } \
45 
-    }
46 
-
47 
-#define SnP_OverwriteBytes(state, data, offset, length, SnP_OverwriteLanes, SnP_OverwriteBytesInLane, SnP_laneLengthInBytes) \
48 
-    { \
49 
-        if ((offset) == 0) { \
50 
-            SnP_OverwriteLanes(state, data, (length)/SnP_laneLengthInBytes); \
51 
-            SnP_OverwriteBytesInLane(state, \
52 
-                (length)/SnP_laneLengthInBytes, \
53 
-                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
54 
-                0, \
55 
-                (length)%SnP_laneLengthInBytes); \
56 
-        } \
57 
-        else { \
58 
-            unsigned int _sizeLeft = (length); \
59 
-            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
60 
-            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
61 
-            const unsigned char *_curData = (data); \
62 
-            while(_sizeLeft > 0) { \
63 
-                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
64 
-                if (_bytesInLane > _sizeLeft) \
65 
-                    _bytesInLane = _sizeLeft; \
66 
-                SnP_OverwriteBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
67 
-                _sizeLeft -= _bytesInLane; \
68 
-                _lanePosition++; \
69 
-                _offsetInLane = 0; \
70 
-                _curData += _bytesInLane; \
71 
-            } \
72 
-        } \
73 
-    }
74 
-
75 
-#define SnP_ExtractBytes(state, data, offset, length, SnP_ExtractLanes, SnP_ExtractBytesInLane, SnP_laneLengthInBytes) \
76 
-    { \
77 
-        if ((offset) == 0) { \
78 
-            SnP_ExtractLanes(state, data, (length)/SnP_laneLengthInBytes); \
79 
-            SnP_ExtractBytesInLane(state, \
80 
-                (length)/SnP_laneLengthInBytes, \
81 
-                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
82 
-                0, \
83 
-                (length)%SnP_laneLengthInBytes); \
84 
-        } \
85 
-        else { \
86 
-            unsigned int _sizeLeft = (length); \
87 
-            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
88 
-            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
89 
-            unsigned char *_curData = (data); \
90 
-            while(_sizeLeft > 0) { \
91 
-                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
92 
-                if (_bytesInLane > _sizeLeft) \
93 
-                    _bytesInLane = _sizeLeft; \
94 
-                SnP_ExtractBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
95 
-                _sizeLeft -= _bytesInLane; \
96 
-                _lanePosition++; \
97 
-                _offsetInLane = 0; \
98 
-                _curData += _bytesInLane; \
99 
-            } \
100 
-        } \
101 
-    }
102 
-
103 
-#define SnP_ExtractAndAddBytes(state, input, output, offset, length, SnP_ExtractAndAddLanes, SnP_ExtractAndAddBytesInLane, SnP_laneLengthInBytes) \
104 
-    { \
105 
-        if ((offset) == 0) { \
106 
-            SnP_ExtractAndAddLanes(state, input, output, (length)/SnP_laneLengthInBytes); \
107 
-            SnP_ExtractAndAddBytesInLane(state, \
108 
-                (length)/SnP_laneLengthInBytes, \
109 
-                (input)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
110 
-                (output)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
111 
-                0, \
112 
-                (length)%SnP_laneLengthInBytes); \
113 
-        } \
114 
-        else { \
115 
-            unsigned int _sizeLeft = (length); \
116 
-            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
117 
-            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
118 
-            const unsigned char *_curInput = (input); \
119 
-            unsigned char *_curOutput = (output); \
120 
-            while(_sizeLeft > 0) { \
121 
-                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
122 
-                if (_bytesInLane > _sizeLeft) \
123 
-                    _bytesInLane = _sizeLeft; \
124 
-                SnP_ExtractAndAddBytesInLane(state, _lanePosition, _curInput, _curOutput, _offsetInLane, _bytesInLane); \
125 
-                _sizeLeft -= _bytesInLane; \
126 
-                _lanePosition++; \
127 
-                _offsetInLane = 0; \
128 
-                _curInput += _bytesInLane; \
129 
-                _curOutput += _bytesInLane; \
130 
-            } \
131 
-        } \
132 
-    }
133 
-
134 
-#endif
Browse code

start implementation of undo and unsaved in redata. tentative sha3-512 support for unsaved integrity check

Dario Rodriguez authored on 26/02/2019 21:26:05
Showing 1 changed files
keccak/SnP-Relaned.h
History View file @ 16296c5
1 1 
new file mode 100644
... ... 
@@ -0,0 +1,134 @@
1 
+/*
2 
+Implementation by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
3 
+Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer, hereby
4 
+denoted as "the implementer".
5 
+
6 
+For more information, feedback or questions, please refer to our websites:
7 
+http://keccak.noekeon.org/
8 
+http://keyak.noekeon.org/
9 
+http://ketje.noekeon.org/
10 
+
11 
+To the extent possible under law, the implementer has waived all copyright
12 
+and related or neighboring rights to the source code in this file.
13 
+http://creativecommons.org/publicdomain/zero/1.0/
14 
+*/
15 
+
16 
+#ifndef _SnP_Relaned_h_
17 
+#define _SnP_Relaned_h_
18 
+
19 
+#define SnP_AddBytes(state, data, offset, length, SnP_AddLanes, SnP_AddBytesInLane, SnP_laneLengthInBytes) \
20 
+    { \
21 
+        if ((offset) == 0) { \
22 
+            SnP_AddLanes(state, data, (length)/SnP_laneLengthInBytes); \
23 
+            SnP_AddBytesInLane(state, \
24 
+                (length)/SnP_laneLengthInBytes, \
25 
+                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
26 
+                0, \
27 
+                (length)%SnP_laneLengthInBytes); \
28 
+        } \
29 
+        else { \
30 
+            unsigned int _sizeLeft = (length); \
31 
+            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
32 
+            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
33 
+            const unsigned char *_curData = (data); \
34 
+            while(_sizeLeft > 0) { \
35 
+                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
36 
+                if (_bytesInLane > _sizeLeft) \
37 
+                    _bytesInLane = _sizeLeft; \
38 
+                SnP_AddBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
39 
+                _sizeLeft -= _bytesInLane; \
40 
+                _lanePosition++; \
41 
+                _offsetInLane = 0; \
42 
+                _curData += _bytesInLane; \
43 
+            } \
44 
+        } \
45 
+    }
46 
+
47 
+#define SnP_OverwriteBytes(state, data, offset, length, SnP_OverwriteLanes, SnP_OverwriteBytesInLane, SnP_laneLengthInBytes) \
48 
+    { \
49 
+        if ((offset) == 0) { \
50 
+            SnP_OverwriteLanes(state, data, (length)/SnP_laneLengthInBytes); \
51 
+            SnP_OverwriteBytesInLane(state, \
52 
+                (length)/SnP_laneLengthInBytes, \
53 
+                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
54 
+                0, \
55 
+                (length)%SnP_laneLengthInBytes); \
56 
+        } \
57 
+        else { \
58 
+            unsigned int _sizeLeft = (length); \
59 
+            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
60 
+            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
61 
+            const unsigned char *_curData = (data); \
62 
+            while(_sizeLeft > 0) { \
63 
+                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
64 
+                if (_bytesInLane > _sizeLeft) \
65 
+                    _bytesInLane = _sizeLeft; \
66 
+                SnP_OverwriteBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
67 
+                _sizeLeft -= _bytesInLane; \
68 
+                _lanePosition++; \
69 
+                _offsetInLane = 0; \
70 
+                _curData += _bytesInLane; \
71 
+            } \
72 
+        } \
73 
+    }
74 
+
75 
+#define SnP_ExtractBytes(state, data, offset, length, SnP_ExtractLanes, SnP_ExtractBytesInLane, SnP_laneLengthInBytes) \
76 
+    { \
77 
+        if ((offset) == 0) { \
78 
+            SnP_ExtractLanes(state, data, (length)/SnP_laneLengthInBytes); \
79 
+            SnP_ExtractBytesInLane(state, \
80 
+                (length)/SnP_laneLengthInBytes, \
81 
+                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
82 
+                0, \
83 
+                (length)%SnP_laneLengthInBytes); \
84 
+        } \
85 
+        else { \
86 
+            unsigned int _sizeLeft = (length); \
87 
+            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
88 
+            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
89 
+            unsigned char *_curData = (data); \
90 
+            while(_sizeLeft > 0) { \
91 
+                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
92 
+                if (_bytesInLane > _sizeLeft) \
93 
+                    _bytesInLane = _sizeLeft; \
94 
+                SnP_ExtractBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
95 
+                _sizeLeft -= _bytesInLane; \
96 
+                _lanePosition++; \
97 
+                _offsetInLane = 0; \
98 
+                _curData += _bytesInLane; \
99 
+            } \
100 
+        } \
101 
+    }
102 
+
103 
+#define SnP_ExtractAndAddBytes(state, input, output, offset, length, SnP_ExtractAndAddLanes, SnP_ExtractAndAddBytesInLane, SnP_laneLengthInBytes) \
104 
+    { \
105 
+        if ((offset) == 0) { \
106 
+            SnP_ExtractAndAddLanes(state, input, output, (length)/SnP_laneLengthInBytes); \
107 
+            SnP_ExtractAndAddBytesInLane(state, \
108 
+                (length)/SnP_laneLengthInBytes, \
109 
+                (input)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
110 
+                (output)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
111 
+                0, \
112 
+                (length)%SnP_laneLengthInBytes); \
113 
+        } \
114 
+        else { \
115 
+            unsigned int _sizeLeft = (length); \
116 
+            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
117 
+            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
118 
+            const unsigned char *_curInput = (input); \
119 
+            unsigned char *_curOutput = (output); \
120 
+            while(_sizeLeft > 0) { \
121 
+                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
122 
+                if (_bytesInLane > _sizeLeft) \
123 
+                    _bytesInLane = _sizeLeft; \
124 
+                SnP_ExtractAndAddBytesInLane(state, _lanePosition, _curInput, _curOutput, _offsetInLane, _bytesInLane); \
125 
+                _sizeLeft -= _bytesInLane; \
126 
+                _lanePosition++; \
127 
+                _offsetInLane = 0; \
128 
+                _curInput += _bytesInLane; \
129 
+                _curOutput += _bytesInLane; \
130 
+            } \
131 
+        } \
132 
+    }
133 
+
134 
+#endif