Allow MatrixSSL code to compile inside gPXE
[people/xl0/gpxe.git] / src / crypto / cryptoLayer.h
1 #ifndef _MATRIXSSL_CRYPTOLAYER_H
2 #define _MATRIXSSL_CRYPTOLAYER_H
3
4 /** @file
5  *
6  * Compatibility layer for MatrixSSL
7  *
8  */
9
10 #include <stdint.h>
11 #include <stddef.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <ctype.h>
15 #include <assert.h>
16 #include <byteswap.h>
17 #include <gpxe/bitops.h>
18 #include <gpxe/crypto.h>
19
20 /* Drag in pscrypto.h */
21 typedef uint64_t ulong64;
22 typedef void psPool_t;
23 #define SMALL_CODE
24 #define USE_INT64
25 #define USE_RSA
26 #define USE_RSA_PUBLIC_ENCRYPT
27 #define CRYPT
28 #include "matrixssl/pscrypto.h"
29 #define SMALL_CODE
30 #undef CLEAN_STACK
31
32 #define sslAssert( ... ) assert ( __VA_ARGS__ )
33
34 static inline void * psMalloc ( psPool_t *pool __unused, size_t len ) {
35         return malloc ( len );
36 }
37
38 static inline void * psRealloc ( void *ptr, size_t len ) {
39         return realloc ( ptr, len );
40 }
41
42 static inline void psFree ( void *ptr ) {
43         free ( ptr );
44 }
45
46 #define matrixStrDebugMsg( ... ) DBG ( __VA_ARGS__ )
47 #define matrixIntDebugMsg( ... ) DBG ( __VA_ARGS__ )
48
49 /* Use our standard cpu_to_leXX etc. macros */
50
51 #undef LOAD32L
52 #define LOAD32L( cpu32, ptr ) do {                              \
53                 uint32_t *le32 = ( ( uint32_t * ) ptr );        \
54                 cpu32 = le32_to_cpu ( *le32 );                  \
55         } while ( 0 )
56
57 #undef LOAD32H
58 #define LOAD32H( cpu32, ptr ) do {                              \
59                 uint32_t *be32 = ( ( uint32_t * ) ptr );        \
60                 cpu32 = be32_to_cpu ( *be32 );                  \
61         } while ( 0 )
62
63 #undef LOAD64L
64 #define LOAD64L( cpu64, ptr ) do {                              \
65                 uint64_t *le64 = ( ( uint64_t * ) ptr );        \
66                 cpu64 = le64_to_cpu ( *le64 );                  \
67         } while ( 0 )
68
69 #undef LOAD64H
70 #define LOAD64H( cpu64, ptr ) do {                              \
71                 uint64_t *be64 = ( ( uint64_t * ) ptr );        \
72                 cpu64 = be64_to_cpu ( *be64 );                  \
73         } while ( 0 )
74
75 #undef STORE32L
76 #define STORE32L( cpu32, ptr ) do {                             \
77                 uint32_t *le32 = ( ( uint32_t * ) ptr );        \
78                 *le32 = cpu_to_le32 ( cpu32 );                  \
79         } while ( 0 )
80
81 #undef STORE32H
82 #define STORE32H( cpu32, ptr ) do {                             \
83                 uint32_t *be32 = ( ( uint32_t * ) ptr );        \
84                 *be32 = cpu_to_be32 ( cpu32 );                  \
85         } while ( 0 )
86
87 #undef STORE64L
88 #define STORE64L( cpu64, ptr ) do {                             \
89                 uint64_t *le64 = ( ( uint64_t * ) ptr );        \
90                 *le64 = cpu_to_le64 ( cpu64 );                  \
91         } while ( 0 )
92
93 #undef STORE64H
94 #define STORE64H( cpu64, ptr ) do {                             \
95                 uint64_t *be64 = ( ( uint64_t * ) ptr );        \
96                 *be64 = cpu_to_be64 ( cpu64 );                  \
97         } while ( 0 )
98
99 /* Use rolXX etc. from bitops.h */
100
101 #undef ROL
102 #define ROL( data, rotation )    rol32 ( (data), (rotation) )
103 #undef ROLc
104 #define ROLc( data, rotation )   rol32 ( (data), (rotation) )
105 #undef ROR
106 #define ROR( data, rotation )    ror32 ( (data), (rotation) )
107 #undef RORc
108 #define RORc( data, rotation )   ror32 ( (data), (rotation) )
109 #undef ROL64
110 #define ROL64( data, rotation )  rol64 ( (data), (rotation) )
111 #undef ROL64c
112 #define ROL64c( data, rotation ) rol64 ( (data), (rotation) )
113 #undef ROR64
114 #define ROR64( data, rotation )  ror64 ( (data), (rotation) )
115 #undef ROR64c
116 #define ROR64c( data, rotation ) ror64 ( (data), (rotation) )
117
118 #endif /* _MATRIXSSL_CRYPTOLAYER_H */